diff --git a/astylerc b/astylerc
index dd738b7..249747a 100644
--- a/astylerc
+++ b/astylerc
@@ -1,11 +1,26 @@
+# Bracket Style Options
 --style=kr
-        --pad-header
-        --max-code-length=120
-                          --convert-tabs
-                          --indent-switches
-                          --pad-oper
-                          --align-pointer=name
-                                  --align-reference=name
-                                          --preserve-date
-                                          --lineend=linux
-                                                  --break-blocks
\ No newline at end of file
+
+# Tab Options
+--indent=spaces=4
+
+# Indentation Options
+--indent-switches
+
+# Padding Options
+--pad-header
+--break-blocks
+--pad-oper
+--unpad-paren
+--align-pointer=name
+--align-reference=name
+
+# Formatting Options
+--add-brackets
+--convert-tabs
+--max-code-length=120
+
+# Other Options
+--preserve-date
+--formatted
+--lineend=linux
diff --git a/src/api.c b/src/api.c
index 58cb2c7..87e1e8a 100644
--- a/src/api.c
+++ b/src/api.c
@@ -46,8 +46,9 @@ extern struct user_settings *user_settings;
 
 void api_display(const char *const msg)
 {
-    if (msg == NULL)
+    if (msg == NULL) {
         return;
+    }
 
     self_window = get_active_window();
     line_info_add(self_window, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
@@ -63,8 +64,9 @@ char *api_get_nick(void)
     size_t   len  = tox_self_get_name_size(user_tox);
     uint8_t *name = malloc(len + 1);
 
-    if (name == NULL)
+    if (name == NULL) {
         return NULL;
+    }
 
     tox_self_get_name(user_tox, name);
     name[len] = '\0';
@@ -81,8 +83,9 @@ char *api_get_status_message(void)
     size_t   len    = tox_self_get_status_message_size(user_tox);
     uint8_t *status = malloc(len + 1);
 
-    if (status == NULL)
+    if (status == NULL) {
         return NULL;
+    }
 
     tox_self_get_status_message(user_tox, status);
     status[len] = '\0';
@@ -91,14 +94,16 @@ char *api_get_status_message(void)
 
 void api_send(const char *msg)
 {
-    if (msg == NULL || self_window->chatwin->cqueue == NULL)
+    if (msg == NULL || self_window->chatwin->cqueue == NULL) {
         return;
+    }
 
     char *name = api_get_nick();
     char  timefrmt[TIME_STR_SIZE];
 
-    if (name == NULL)
+    if (name == NULL) {
         return;
+    }
 
     self_window = get_active_window();
     get_time_str(timefrmt, sizeof(timefrmt));
@@ -144,9 +149,12 @@ void cmd_run(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
     cur_window  = window;
     self_window = self;
 
-    if ( argc != 1 ) {
-        if ( argc < 1 ) error_str = "Path must be specified!";
-        else error_str = "Only one argument allowed!";
+    if (argc != 1) {
+        if (argc < 1) {
+            error_str = "Path must be specified!";
+        } else {
+            error_str = "Only one argument allowed!";
+        }
 
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, error_str);
         return;
@@ -154,7 +162,7 @@ void cmd_run(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
 
     fp = fopen(argv[1], "r");
 
-    if ( fp == NULL ) {
+    if (fp == NULL) {
         error_str = "Path does not exist!";
 
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, error_str);
@@ -173,8 +181,9 @@ void invoke_autoruns(WINDOW *window, ToxWindow *self)
     DIR    *d;
     FILE   *fp;
 
-    if (user_settings->autorun_path[0] == '\0')
+    if (user_settings->autorun_path[0] == '\0') {
         return;
+    }
 
     d = opendir(user_settings->autorun_path);
 
diff --git a/src/audio_call.c b/src/audio_call.c
index b2b7929..976b5b5 100644
--- a/src/audio_call.c
+++ b/src/audio_call.c
@@ -73,44 +73,46 @@ static int set_call(Call *call, bool start)
     call->vout_idx = -1;
 #endif /* VIDEO */
 
-    if ( start ) {
+    if (start) {
         call->ttas = true;
 
-        if ( pthread_mutex_init(&call->mutex, NULL) != 0 )
+        if (pthread_mutex_init(&call->mutex, NULL) != 0) {
             return -1;
+        }
     } else {
         call->ttid = 0;
 
-        if ( pthread_mutex_destroy(&call->mutex) != 0 )
+        if (pthread_mutex_destroy(&call->mutex) != 0) {
             return -1;
+        }
     }
 
     return 0;
 }
 
-void call_cb                 ( ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled,
-                               void *user_data );
-void callstate_cb            ( ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data );
-void receive_audio_frame_cb  ( ToxAV *av, uint32_t friend_number, int16_t const *pcm, size_t sample_count,
-                               uint8_t channels, uint32_t sampling_rate, void *user_data );
-void receive_video_frame_cb  ( ToxAV *av, uint32_t friend_number,
-                               uint16_t width, uint16_t height,
-                               uint8_t const *y, uint8_t const *u, uint8_t const *v, uint8_t const *a,
-                               int32_t ystride, int32_t ustride, int32_t vstride, int32_t astride, void *user_data );
+void call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled,
+             void *user_data);
+void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data);
+void receive_audio_frame_cb(ToxAV *av, uint32_t friend_number, int16_t const *pcm, size_t sample_count,
+                            uint8_t channels, uint32_t sampling_rate, void *user_data);
+void receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
+                            uint16_t width, uint16_t height,
+                            uint8_t const *y, uint8_t const *u, uint8_t const *v, uint8_t const *a,
+                            int32_t ystride, int32_t ustride, int32_t vstride, int32_t astride, void *user_data);
 
-void callback_recv_invite   ( Tox *m, uint32_t friend_number );
-void callback_recv_ringing  ( uint32_t friend_number );
-void callback_recv_starting ( uint32_t friend_number );
-void callback_recv_ending   ( uint32_t friend_number );
-void callback_call_started  ( uint32_t friend_number );
-void callback_call_canceled ( uint32_t friend_number );
-void callback_call_rejected ( uint32_t friend_number );
-void callback_call_ended    ( uint32_t friend_number );
+void callback_recv_invite(Tox *m, uint32_t friend_number);
+void callback_recv_ringing(uint32_t friend_number);
+void callback_recv_starting(uint32_t friend_number);
+void callback_recv_ending(uint32_t friend_number);
+void callback_call_started(uint32_t friend_number);
+void callback_call_canceled(uint32_t friend_number);
+void callback_call_rejected(uint32_t friend_number);
+void callback_call_ended(uint32_t friend_number);
 
-void write_device_callback( uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
-                            uint32_t sample_rate );
+void write_device_callback(uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
+                           uint32_t sample_rate);
 
-static void print_err (ToxWindow *self, const char *error_str)
+static void print_err(ToxWindow *self, const char *error_str)
 {
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", error_str);
 }
@@ -136,14 +138,14 @@ ToxAV *init_audio(ToxWindow *self, Tox *tox)
     CallControl.video_frame_duration = 0;
 #endif /* VIDEO */
 
-    if ( !CallControl.av ) {
+    if (!CallControl.av) {
         CallControl.audio_errors |= ae_StartingCoreAudio;
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init ToxAV");
 
         return NULL;
     }
 
-    if ( init_devices(CallControl.av) == de_InternalError ) {
+    if (init_devices(CallControl.av) == de_InternalError) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init devices");
         toxav_kill(CallControl.av);
 
@@ -161,11 +163,13 @@ void terminate_audio()
 {
     int i;
 
-    for (i = 0; i < CallControl.max_calls; ++i)
+    for (i = 0; i < CallControl.max_calls; ++i) {
         stop_transmission(&CallControl.calls[i], i);
+    }
 
-    if ( CallControl.av )
+    if (CallControl.av) {
         toxav_kill(CallControl.av);
+    }
 
     terminate_devices();
 }
@@ -177,48 +181,54 @@ void read_device_callback(const int16_t *captured, uint32_t size, void *data)
     int64_t sample_count = ((int64_t) CallControl.audio_sample_rate) * \
                            ((int64_t) CallControl.audio_frame_duration) / 1000;
 
-    if ( sample_count <= 0 || toxav_audio_send_frame(CallControl.av, friend_number,
+    if (sample_count <= 0 || toxav_audio_send_frame(CallControl.av, friend_number,
             captured, sample_count,
             CallControl.audio_channels,
-            CallControl.audio_sample_rate, &error) == false ) {
+            CallControl.audio_sample_rate, &error) == false) {
     }
 }
 
 void write_device_callback(uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
                            uint32_t sample_rate)
 {
-    if ( CallControl.calls[friend_number].ttas )
+    if (CallControl.calls[friend_number].ttas) {
         write_out(CallControl.calls[friend_number].out_idx, PCM, sample_count, channels, sample_rate);
+    }
 }
 
 int start_transmission(ToxWindow *self, Call *call)
 {
-    if ( !self || !CallControl.av ) {
+    if (!self || !CallControl.av) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare transmission");
         return -1;
     }
 
-    if (set_call(call, true) == -1)
+    if (set_call(call, true) == -1) {
         return -1;
+    }
 
     DeviceError error = open_primary_device(input, &call->in_idx,
                                             CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels);
 
-    if ( error != de_None ) {
-        if ( error == de_FailedStart)
+    if (error != de_None) {
+        if (error == de_FailedStart) {
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to start input device");
+        }
 
-        if ( error == de_InternalError )
+        if (error == de_InternalError) {
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Internal error with opening input device");
+        }
     }
 
-    if ( register_device_callback(self->num, call->in_idx,
-                                  read_device_callback, &self->num, true) != de_None)
+    if (register_device_callback(self->num, call->in_idx,
+                                 read_device_callback, &self->num, true) != de_None)
         /* Set VAD as true for all; TODO: Make it more dynamic */
+    {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to register input handler!");
+    }
 
-    if ( open_primary_device(output, &call->out_idx,
-                             CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels) != de_None ) {
+    if (open_primary_device(output, &call->out_idx,
+                            CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels) != de_None) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open output device!");
         call->has_output = 0;
     }
@@ -228,23 +238,27 @@ int start_transmission(ToxWindow *self, Call *call)
 
 int stop_transmission(Call *call, uint32_t friend_number)
 {
-    if ( call->ttas ) {
+    if (call->ttas) {
         TOXAV_ERR_CALL_CONTROL error = TOXAV_ERR_CALL_CONTROL_OK;
 
-        if ( CallControl.call_state > TOXAV_FRIEND_CALL_STATE_FINISHED )
+        if (CallControl.call_state > TOXAV_FRIEND_CALL_STATE_FINISHED) {
             toxav_call_control(CallControl.av, friend_number, TOXAV_CALL_CONTROL_CANCEL, &error);
+        }
 
-        if ( error == TOXAV_ERR_CALL_CONTROL_OK ) {
+        if (error == TOXAV_ERR_CALL_CONTROL_OK) {
             call->ttas = false;
 
-            if ( call->in_idx != -1 )
+            if (call->in_idx != -1) {
                 close_device(input, call->in_idx);
+            }
 
-            if ( call->out_idx != -1 )
+            if (call->out_idx != -1) {
                 close_device(output, call->out_idx);
+            }
 
-            if ( set_call(call, false) == -1 )
+            if (set_call(call, false) == -1) {
                 return -1;
+            }
 
             return 0;
         } else {
@@ -277,8 +291,8 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
 {
     CallControl.call_state = state;
 
-    switch ( state ) {
-        case ( TOXAV_FRIEND_CALL_STATE_ERROR ):
+    switch (state) {
+        case (TOXAV_FRIEND_CALL_STATE_ERROR):
             line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "ToxAV callstate error!");
 
 #ifdef VIDEO
@@ -291,11 +305,12 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
 
             break;
 
-        case ( TOXAV_FRIEND_CALL_STATE_FINISHED ):
-            if ( CallControl.pending_call )
+        case (TOXAV_FRIEND_CALL_STATE_FINISHED):
+            if (CallControl.pending_call) {
                 callback_call_rejected(friend_number);
-            else
+            } else {
                 callback_call_ended(friend_number);
+            }
 
 #ifdef VIDEO
             callback_recv_video_end(friend_number);
@@ -311,7 +326,7 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
             break;
 
         default:
-            if ( CallControl.pending_call ) {
+            if (CallControl.pending_call) {
                 /* Start answered call */
                 callback_call_started(friend_number);
                 CallControl.pending_call = false;
@@ -320,10 +335,11 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
 #ifdef VIDEO
 
                 /* Handle receiving client video call states */
-                if ( state & TOXAV_FRIEND_CALL_STATE_SENDING_V )
+                if (state & TOXAV_FRIEND_CALL_STATE_SENDING_V) {
                     callback_recv_video_starting(friend_number);
-                else if ( state & ~TOXAV_FRIEND_CALL_STATE_SENDING_V )
+                } else if (state & ~TOXAV_FRIEND_CALL_STATE_SENDING_V) {
                     callback_recv_video_end(friend_number);
+                }
 
 #endif /* VIDEO */
             }
@@ -347,12 +363,14 @@ void audio_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_t audio_
 
 void callback_recv_invite(Tox *m, uint32_t friend_number)
 {
-    if (friend_number >= Friends.max_idx)
+    if (friend_number >= Friends.max_idx) {
         return;
+    }
 
     if (Friends.list[friend_number].chatwin == -1) {
-        if (get_num_active_windows() >= MAX_WINDOWS_NUM)
+        if (get_num_active_windows() >= MAX_WINDOWS_NUM) {
             return;
+        }
 
         Friends.list[friend_number].chatwin = add_window(m, new_chat(m, Friends.list[friend_number].num));
     }
@@ -384,11 +402,12 @@ void callback_recv_starting(uint32_t friend_number)
     int i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if ( windows[i].onStarting != NULL && windows[i].num == friend_number ) {
+        if (windows[i].onStarting != NULL && windows[i].num == friend_number) {
             windows[i].onStarting(&windows[i], CallControl.av, friend_number, CallControl.call_state);
 
-            if ( 0 != start_transmission(&windows[i], &CallControl.calls[friend_number]) ) /* YEAH! */
+            if (0 != start_transmission(&windows[i], &CallControl.calls[friend_number])) { /* YEAH! */
                 line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
+            }
 
             return;
         }
@@ -412,10 +431,10 @@ void callback_call_started(uint32_t friend_number)
     int i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i)
-        if ( windows[i].onStart != NULL && windows[i].num == friend_number ) {
+        if (windows[i].onStart != NULL && windows[i].num == friend_number) {
             windows[i].onStart(&windows[i], CallControl.av, friend_number, CallControl.call_state);
 
-            if ( 0 != start_transmission(&windows[i], &CallControl.calls[friend_number]) ) {/* YEAH! */
+            if (0 != start_transmission(&windows[i], &CallControl.calls[friend_number])) {  /* YEAH! */
                 line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
                 return;
             }
@@ -468,34 +487,40 @@ void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
     TOXAV_ERR_CALL error;
     const char *error_str;
 
-    if ( argc != 0 ) {
+    if (argc != 0) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !CallControl.av ) {
+    if (!CallControl.av) {
         error_str = "ToxAV not supported!";
         goto on_error;
     }
 
-    if ( !self->stb->connection ) {
+    if (!self->stb->connection) {
         error_str = "Friend is offline.";
         goto on_error;
     }
 
-    if ( CallControl.pending_call ) {
+    if (CallControl.pending_call) {
         error_str = "Already a pending call!";
         goto on_error;
     }
 
     toxav_call(CallControl.av, self->num, CallControl.audio_bit_rate, CallControl.video_bit_rate, &error);
 
-    if ( error != TOXAV_ERR_CALL_OK ) {
-        if ( error == TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL ) error_str = "Already in a call!";
-        else if ( error == TOXAV_ERR_CALL_MALLOC ) error_str = "Memory allocation issue";
-        else if ( error == TOXAV_ERR_CALL_FRIEND_NOT_FOUND ) error_str = "Friend number invalid";
-        else if ( error == TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED ) error_str = "Friend is valid but not currently connected";
-        else error_str = "Internal error!";
+    if (error != TOXAV_ERR_CALL_OK) {
+        if (error == TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL) {
+            error_str = "Already in a call!";
+        } else if (error == TOXAV_ERR_CALL_MALLOC) {
+            error_str = "Memory allocation issue";
+        } else if (error == TOXAV_ERR_CALL_FRIEND_NOT_FOUND) {
+            error_str = "Friend number invalid";
+        } else if (error == TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED) {
+            error_str = "Friend is valid but not currently connected";
+        } else {
+            error_str = "Internal error!";
+        }
 
         goto on_error;
     }
@@ -513,29 +538,35 @@ void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     TOXAV_ERR_ANSWER error;
     const char *error_str;
 
-    if ( argc != 0 ) {
+    if (argc != 0) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !CallControl.av ) {
+    if (!CallControl.av) {
         error_str = "Audio not supported!";
         goto on_error;
     }
 
-    if ( !CallControl.pending_call ) {
+    if (!CallControl.pending_call) {
         error_str = "No incoming call!";
         goto on_error;
     }
 
     toxav_answer(CallControl.av, self->num, CallControl.audio_bit_rate, CallControl.video_bit_rate, &error);
 
-    if ( error != TOXAV_ERR_ANSWER_OK ) {
-        if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING ) error_str = "No incoming call!";
-        else if ( error == TOXAV_ERR_ANSWER_CODEC_INITIALIZATION ) error_str = "Failed to initialize codecs!";
-        else if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND ) error_str = "Friend not found!";
-        else if ( error == TOXAV_ERR_ANSWER_INVALID_BIT_RATE ) error_str = "Invalid bit rate!";
-        else error_str = "Internal error!";
+    if (error != TOXAV_ERR_ANSWER_OK) {
+        if (error == TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING) {
+            error_str = "No incoming call!";
+        } else if (error == TOXAV_ERR_ANSWER_CODEC_INITIALIZATION) {
+            error_str = "Failed to initialize codecs!";
+        } else if (error == TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND) {
+            error_str = "Friend not found!";
+        } else if (error == TOXAV_ERR_ANSWER_INVALID_BIT_RATE) {
+            error_str = "Invalid bit rate!";
+        } else {
+            error_str = "Internal error!";
+        }
 
         goto on_error;
     }
@@ -546,24 +577,24 @@ void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_reject(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str;
 
-    if ( argc != 0 ) {
+    if (argc != 0) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !CallControl.av ) {
+    if (!CallControl.av) {
         error_str = "Audio not supported!";
         goto on_error;
     }
 
-    if ( !CallControl.pending_call ) {
+    if (!CallControl.pending_call) {
         error_str = "No incoming call!";
         goto on_error;
     }
@@ -577,24 +608,24 @@ void cmd_reject(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str = NULL;
 
-    if ( !CallControl.av ) {
+    if (!CallControl.av) {
         error_str = "Audio not supported!";
         goto on_error;
     }
 
-    if ( argc != 0 ) {
+    if (argc != 0) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !self->is_call && !CallControl.pending_call ) {
+    if (!self->is_call && !CallControl.pending_call) {
         error_str = "Not in a call.";
         goto on_error;
     }
@@ -606,27 +637,32 @@ void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     stop_current_call(self);
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str;
 
-    if ( argc != 1 ) {
-        if ( argc < 1 ) error_str = "Type must be specified!";
-        else error_str = "Only one argument allowed!";
+    if (argc != 1) {
+        if (argc < 1) {
+            error_str = "Type must be specified!";
+        } else {
+            error_str = "Only one argument allowed!";
+        }
 
         goto on_error;
     }
 
     DeviceType type;
 
-    if ( strcasecmp(argv[1], "in") == 0 ) /* Input devices */
+    if (strcasecmp(argv[1], "in") == 0) { /* Input devices */
         type = input;
+    }
 
-    else if ( strcasecmp(argv[1], "out") == 0 ) /* Output devices */
+    else if (strcasecmp(argv[1], "out") == 0) { /* Output devices */
         type = output;
+    }
 
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
@@ -640,7 +676,7 @@ void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 /* This changes primary device only */
@@ -648,21 +684,27 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
 {
     const char *error_str;
 
-    if ( argc != 2 ) {
-        if ( argc < 1 ) error_str = "Type must be specified!";
-        else if ( argc < 2 ) error_str = "Must have id!";
-        else error_str = "Only two arguments allowed!";
+    if (argc != 2) {
+        if (argc < 1) {
+            error_str = "Type must be specified!";
+        } else if (argc < 2) {
+            error_str = "Must have id!";
+        } else {
+            error_str = "Only two arguments allowed!";
+        }
 
         goto on_error;
     }
 
     DeviceType type;
 
-    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+    if (strcmp(argv[1], "in") == 0) { /* Input devices */
         type = input;
+    }
 
-    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+    else if (strcmp(argv[1], "out") == 0) { /* Output devices */
         type = output;
+    }
 
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
@@ -673,40 +715,46 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
     char *end;
     long int selection = strtol(argv[2], &end, 10);
 
-    if ( *end ) {
+    if (*end) {
         error_str = "Invalid input";
         goto on_error;
     }
 
-    if ( set_primary_device(type, selection) == de_InvalidSelection ) {
+    if (set_primary_device(type, selection) == de_InvalidSelection) {
         error_str = "Invalid selection!";
         goto on_error;
     }
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str;
 
-    if ( argc != 2 ) {
-        if ( argc < 1 ) error_str = "Type must be specified!";
-        else if ( argc < 2 ) error_str = "Must have id!";
-        else error_str = "Only two arguments allowed!";
+    if (argc != 2) {
+        if (argc < 1) {
+            error_str = "Type must be specified!";
+        } else if (argc < 2) {
+            error_str = "Must have id!";
+        } else {
+            error_str = "Only two arguments allowed!";
+        }
 
         goto on_error;
     }
 
     DeviceType type;
 
-    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+    if (strcmp(argv[1], "in") == 0) { /* Input devices */
         type = input;
+    }
 
-    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+    else if (strcmp(argv[1], "out") == 0) { /* Output devices */
         type = output;
+    }
 
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
@@ -717,24 +765,24 @@ void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
     char *end;
     long int selection = strtol(argv[2], &end, 10);
 
-    if ( *end ) {
+    if (*end) {
         error_str = "Invalid input";
         goto on_error;
     }
 
-    if ( selection_valid(type, selection) == de_InvalidSelection ) {
+    if (selection_valid(type, selection) == de_InvalidSelection) {
         error_str = "Invalid selection!";
         goto on_error;
     }
 
     /* If call is active, change device */
-    if ( self->is_call ) {
+    if (self->is_call) {
         Call *this_call = &CallControl.calls[self->num];
 
-        if ( this_call->ttas ) {
+        if (this_call->ttas) {
 
 
-            if ( type == output ) {
+            if (type == output) {
                 pthread_mutex_lock(&this_call->mutex);
                 close_device(output, this_call->out_idx);
                 this_call->has_output = open_device(output, selection, &this_call->out_idx,
@@ -756,27 +804,32 @@ void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str;
 
-    if ( argc != 1 ) {
-        if ( argc < 1 ) error_str = "Type must be specified!";
-        else error_str = "Only two arguments allowed!";
+    if (argc != 1) {
+        if (argc < 1) {
+            error_str = "Type must be specified!";
+        } else {
+            error_str = "Only two arguments allowed!";
+        }
 
         goto on_error;
     }
 
     DeviceType type;
 
-    if ( strcasecmp(argv[1], "in") == 0 ) /* Input devices */
+    if (strcasecmp(argv[1], "in") == 0) { /* Input devices */
         type = input;
+    }
 
-    else if ( strcasecmp(argv[1], "out") == 0 ) /* Output devices */
+    else if (strcasecmp(argv[1], "out") == 0) { /* Output devices */
         type = output;
+    }
 
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
@@ -785,12 +838,12 @@ void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
 
 
     /* If call is active, use this_call values */
-    if ( self->is_call ) {
+    if (self->is_call) {
         Call *this_call = &CallControl.calls[self->num];
 
         pthread_mutex_lock(&this_call->mutex);
 
-        if ( type == input ) {
+        if (type == input) {
             device_mute(type, this_call->in_idx);
             self->chatwin->infobox.in_is_muted ^= 1;
         } else {
@@ -804,16 +857,19 @@ void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
     return;
 
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_sense(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str;
 
-    if ( argc != 1 ) {
-        if ( argc < 1 ) error_str = "Must have value!";
-        else error_str = "Only two arguments allowed!";
+    if (argc != 1) {
+        if (argc < 1) {
+            error_str = "Must have value!";
+        } else {
+            error_str = "Only two arguments allowed!";
+        }
 
         goto on_error;
     }
@@ -821,13 +877,13 @@ void cmd_sense(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[M
     char *end;
     float value = strtof(argv[1], &end);
 
-    if ( *end ) {
+    if (*end) {
         error_str = "Invalid input";
         goto on_error;
     }
 
     /* Call must be active */
-    if ( self->is_call ) {
+    if (self->is_call) {
         device_set_VAD_treshold(CallControl.calls[self->num].in_idx, value);
         self->chatwin->infobox.vad_lvl = value;
     }
@@ -835,19 +891,19 @@ void cmd_sense(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[M
     return;
 
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_bitrate(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     char *error_str;
 
-    if ( argc != 1 ) {
+    if (argc != 1) {
         error_str = "Must have value!";
         goto on_error;
     }
 
-    if ( self->is_call == false ) {
+    if (self->is_call == false) {
         error_str = "Must be in a call";
         goto on_error;
     }
@@ -885,12 +941,12 @@ void cmd_bitrate(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
     return;
 
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void stop_current_call(ToxWindow *self)
 {
-    if ( CallControl.pending_call ) {
+    if (CallControl.pending_call) {
         toxav_call_control(CallControl.av, self->num, TOXAV_CALL_CONTROL_CANCEL, NULL);
         callback_call_canceled(self->num);
     } else {
diff --git a/src/audio_device.c b/src/audio_device.c
index 9bb31ee..dd0d6f2 100644
--- a/src/audio_device.c
+++ b/src/audio_device.c
@@ -103,13 +103,15 @@ DeviceError init_devices()
     get_devices_names();
 
     // Start poll thread
-    if (pthread_mutex_init(&mutex, NULL) != 0)
+    if (pthread_mutex_init(&mutex, NULL) != 0) {
         return de_InternalError;
+    }
 
     pthread_t thread_id;
 
-    if ( pthread_create(&thread_id, NULL, thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0)
+    if (pthread_create(&thread_id, NULL, thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0) {
         return de_InternalError;
+    }
 
 #ifdef AUDIO
     av = av_;
@@ -127,8 +129,9 @@ DeviceError terminate_devices()
 
     usleep(20000);
 
-    if (pthread_mutex_destroy(&mutex) != 0)
+    if (pthread_mutex_destroy(&mutex) != 0) {
         return (DeviceError) de_InternalError;
+    }
 
     return (DeviceError) de_None;
 }
@@ -140,35 +143,38 @@ void get_devices_names()
 
     size[input] = 0;
 
-    if ( (stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER)) ) {
+    if ((stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER))) {
         ddevice_names[input] = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
 
-        for ( ; *stringed_device_list && size[input] < MAX_DEVICES; ++size[input] ) {
+        for (; *stringed_device_list && size[input] < MAX_DEVICES; ++size[input]) {
             devices_names[input][size[input]] = stringed_device_list;
-            stringed_device_list += strlen( stringed_device_list ) + 1;
+            stringed_device_list += strlen(stringed_device_list) + 1;
         }
     }
 
     size[output] = 0;
 
-    if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
+    if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE) {
         stringed_device_list = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
-    else
+    } else {
         stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+    }
 
     if (stringed_device_list) {
         ddevice_names[output] = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
 
-        for ( ; *stringed_device_list && size[output] < MAX_DEVICES; ++size[output] ) {
+        for (; *stringed_device_list && size[output] < MAX_DEVICES; ++size[output]) {
             devices_names[output][size[output]] = stringed_device_list;
-            stringed_device_list += strlen( stringed_device_list ) + 1;
+            stringed_device_list += strlen(stringed_device_list) + 1;
         }
     }
 }
 
 DeviceError device_mute(DeviceType type, uint32_t device_idx)
 {
-    if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
+    if (device_idx >= MAX_DEVICES) {
+        return de_InvalidSelection;
+    }
 
     lock;
 
@@ -188,7 +194,9 @@ DeviceError device_mute(DeviceType type, uint32_t device_idx)
 #ifdef AUDIO
 DeviceError device_set_VAD_treshold(uint32_t device_idx, float value)
 {
-    if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
+    if (device_idx >= MAX_DEVICES) {
+        return de_InvalidSelection;
+    }
 
     lock;
 
@@ -209,7 +217,9 @@ DeviceError device_set_VAD_treshold(uint32_t device_idx, float value)
 
 DeviceError set_primary_device(DeviceType type, int32_t selection)
 {
-    if (size[type] <= selection || selection < 0) return de_InvalidSelection;
+    if (size[type] <= selection || selection < 0) {
+        return de_InvalidSelection;
+    }
 
     primary_device[type] = selection;
 
@@ -231,9 +241,13 @@ void get_primary_device_name(DeviceType type, char *buf, int size)
 DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx, uint32_t sample_rate,
                         uint32_t frame_duration, uint8_t channels)
 {
-    if (size[type] <= selection || selection < 0) return de_InvalidSelection;
+    if (size[type] <= selection || selection < 0) {
+        return de_InvalidSelection;
+    }
 
-    if (channels != 1 && channels != 2) return de_UnsupportedMode;
+    if (channels != 1 && channels != 2) {
+        return de_UnsupportedMode;
+    }
 
     lock;
 
@@ -246,10 +260,12 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
     if (i == MAX_DEVICES) {
         unlock;
         return de_AllDevicesBusy;
-    } else *device_idx = i;
+    } else {
+        *device_idx = i;
+    }
 
     for (i = 0; i < MAX_DEVICES; i ++) { /* Check if any device has the same selection */
-        if ( running[type][i] && running[type][i]->selection == selection ) {
+        if (running[type][i] && running[type][i]->selection == selection) {
 //             printf("a%d-%d:%p ", selection, i, running[type][i]->dhndl);
 
             running[type][*device_idx] = running[type][i];
@@ -282,7 +298,7 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
     } else {
         device->dhndl = alcOpenDevice(devices_names[type][selection]);
 
-        if ( !device->dhndl ) {
+        if (!device->dhndl) {
             free(device);
             running[type][*device_idx] = NULL;
             unlock;
@@ -299,7 +315,7 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
         uint16_t zeros[frame_size];
         memset(zeros, 0, frame_size * 2);
 
-        for ( i = 0; i < OPENAL_BUFS; ++i ) {
+        for (i = 0; i < OPENAL_BUFS; ++i) {
             alBufferData(device->buffers[i], device->sound_mode, zeros, frame_size * 2, sample_rate);
         }
 
@@ -325,7 +341,9 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx
 
 DeviceError close_device(DeviceType type, uint32_t device_idx)
 {
-    if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
+    if (device_idx >= MAX_DEVICES) {
+        return de_InvalidSelection;
+    }
 
     lock;
     Device *device = running[type][device_idx];
@@ -338,34 +356,45 @@ DeviceError close_device(DeviceType type, uint32_t device_idx)
 
     running[type][device_idx] = NULL;
 
-    if ( !device->ref_count ) {
+    if (!device->ref_count) {
         if (type == input) {
-            if ( !alcCaptureCloseDevice(device->dhndl) ) rc = de_AlError;
+            if (!alcCaptureCloseDevice(device->dhndl)) {
+                rc = de_AlError;
+            }
         } else {
-            if (alcGetCurrentContext() != device->ctx) alcMakeContextCurrent(device->ctx);
+            if (alcGetCurrentContext() != device->ctx) {
+                alcMakeContextCurrent(device->ctx);
+            }
 
             alDeleteSources(1, &device->source);
             alDeleteBuffers(OPENAL_BUFS, device->buffers);
 
             alcMakeContextCurrent(NULL);
 
-            if ( device->ctx ) alcDestroyContext(device->ctx);
+            if (device->ctx) {
+                alcDestroyContext(device->ctx);
+            }
 
-            if ( !alcCloseDevice(device->dhndl) ) rc = de_AlError;
+            if (!alcCloseDevice(device->dhndl)) {
+                rc = de_AlError;
+            }
         }
 
         free(device);
-    } else device->ref_count--;
+    } else {
+        device->ref_count--;
+    }
 
     unlock;
     return rc;
 }
 
-DeviceError register_device_callback( int32_t friend_number, uint32_t device_idx, DataHandleCallback callback,
-                                      void *data, bool enable_VAD)
+DeviceError register_device_callback(int32_t friend_number, uint32_t device_idx, DataHandleCallback callback,
+                                     void *data, bool enable_VAD)
 {
-    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
+    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL) {
         return de_InvalidSelection;
+    }
 
     lock;
     running[input][device_idx]->cb = callback;
@@ -380,11 +409,15 @@ DeviceError register_device_callback( int32_t friend_number, uint32_t device_idx
 inline__ DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_t sample_count, uint8_t channels,
                                uint32_t sample_rate)
 {
-    if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
+    if (device_idx >= MAX_DEVICES) {
+        return de_InvalidSelection;
+    }
 
     Device *device = running[output][device_idx];
 
-    if (!device || device->muted) return de_DeviceNotActive;
+    if (!device || device->muted) {
+        return de_DeviceNotActive;
+    }
 
     pthread_mutex_lock(device->mutex);
 
@@ -399,8 +432,9 @@ inline__ DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_
         alSourceUnqueueBuffers(device->source, processed, bufids);
         alDeleteBuffers(processed - 1, bufids + 1);
         bufid = bufids[0];
-    } else if (queued < 16) alGenBuffers(1, &bufid);
-    else {
+    } else if (queued < 16) {
+        alGenBuffers(1, &bufid);
+    } else {
         pthread_mutex_unlock(device->mutex);
         return de_Busy;
     }
@@ -413,14 +447,16 @@ inline__ DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_
     ALint state;
     alGetSourcei(device->source, AL_SOURCE_STATE, &state);
 
-    if (state != AL_PLAYING) alSourcePlay(device->source);
+    if (state != AL_PLAYING) {
+        alSourcePlay(device->source);
+    }
 
 
     pthread_mutex_unlock(device->mutex);
     return de_None;
 }
 
-void *thread_poll (void *arg) // TODO: maybe use thread for every input source
+void *thread_poll(void *arg)  // TODO: maybe use thread for every input source
 {
     /*
      * NOTE: We only need to poll input devices for data.
@@ -470,7 +506,9 @@ void *thread_poll (void *arg) // TODO: maybe use thread for every input source
                         continue;
                     }
 
-                    if ( device->cb ) device->cb(frame, f_size, device->cb_data);
+                    if (device->cb) {
+                        device->cb(frame, f_size, device->cb_data);
+                    }
                 }
 
                 unlock;
@@ -502,8 +540,9 @@ DeviceError selection_valid(DeviceType type, int32_t selection)
 
 void *get_device_callback_data(uint32_t device_idx)
 {
-    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
+    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL) {
         return NULL;
+    }
 
     return running[input][device_idx]->cb_data;
 }
diff --git a/src/audio_device.h b/src/audio_device.h
index 969588a..bd01bc8 100644
--- a/src/audio_device.h
+++ b/src/audio_device.h
@@ -52,7 +52,7 @@ typedef enum DeviceError {
     de_AlError = -9,
 } DeviceError;
 
-typedef void (*DataHandleCallback) (const int16_t *, uint32_t size, void *data);
+typedef void (*DataHandleCallback)(const int16_t *, uint32_t size, void *data);
 
 
 #ifdef AUDIO
diff --git a/src/autocomplete.c b/src/autocomplete.c
index fe0c935..5900a16 100644
--- a/src/autocomplete.c
+++ b/src/autocomplete.c
@@ -97,16 +97,18 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
 {
     ChatContext *ctx = self->chatwin;
 
-    if (ctx->pos <= 0 || ctx->len <= 0 || ctx->pos > ctx->len || ctx->len >= MAX_STR_SIZE || size > MAX_STR_SIZE)
+    if (ctx->pos <= 0 || ctx->len <= 0 || ctx->pos > ctx->len || ctx->len >= MAX_STR_SIZE || size > MAX_STR_SIZE) {
         return -1;
+    }
 
     const char *L = (char *) list;
     const char *endchrs = " ";
     char ubuf[MAX_STR_SIZE];
 
     /* work with multibyte string copy of buf for simplicity */
-    if (wcs_to_mbs_buf(ubuf, ctx->line, sizeof(ubuf)) == -1)
+    if (wcs_to_mbs_buf(ubuf, ctx->line, sizeof(ubuf)) == -1) {
         return -1;
+    }
 
     /* TODO: generalize this */
     bool dir_search =    !strncmp(ubuf, "/sendfile", strlen("/sendfile"))
@@ -124,14 +126,16 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
     const char *s = dir_search ? strchr(tmp, '\"') : strrchr(tmp, ' ');
     char *sub = calloc(1, strlen(ubuf) + 1);
 
-    if (sub == NULL)
+    if (sub == NULL) {
         exit_toxic_err("failed in complete_line", FATALERR_MEMORY);
+    }
 
     if (!s && !dir_search) {
         strcpy(sub, tmp);
 
-        if (sub[0] != '/')
+        if (sub[0] != '/') {
             endchrs = ": ";
+        }
     } else if (s) {
         strcpy(sub, &s[1]);
 
@@ -139,8 +143,9 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
             int sub_len = strlen(sub);
             int si = char_rfind(sub, '/', sub_len);
 
-            if (si || *sub == '/')
+            if (si || *sub == '/') {
                 memmove(sub, &sub[si + 1], sub_len - si);
+            }
         }
     }
 
@@ -159,17 +164,20 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
         char str[MAX_CMDNAME_SIZE + 1];
         snprintf(str, sizeof(str), "%s", &L[i * size]);
 
-        if (strncasecmp(str, sub, s_len) == 0)
+        if (strncasecmp(str, sub, s_len) == 0) {
             strcpy(matches[n_matches++], str);
+        }
     }
 
     free(sub);
 
-    if (!n_matches)
+    if (!n_matches) {
         return -1;
+    }
 
-    if (!dir_search && n_matches > 1)
+    if (!dir_search && n_matches > 1) {
         print_matches(self, NULL, matches, n_matches, MAX_STR_SIZE);
+    }
 
     char match[MAX_STR_SIZE];
     size_t match_len = get_str_match(self, match, sizeof(match), matches, n_matches);
@@ -179,10 +187,11 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
     }
 
     if (dir_search) {
-        if (n_matches == 1)
+        if (n_matches == 1) {
             endchrs = char_rfind(match, '.', match_len) ? "\"" : "/";
-        else
+        } else {
             endchrs = "";
+        }
     } else if (n_matches > 1) {
         endchrs = "";
     }
@@ -192,8 +201,9 @@ int complete_line(ToxWindow *self, const void *list, size_t n_items, size_t size
     int strt = ctx->pos - s_len;
     int diff = match_len - s_len + n_endchrs;
 
-    if (ctx->len + diff >= MAX_STR_SIZE)
+    if (ctx->len + diff >= MAX_STR_SIZE) {
         return -1;
+    }
 
     char tmpend[MAX_STR_SIZE];
     snprintf(tmpend, sizeof(tmpend), "%s", &ubuf[ctx->pos]);
@@ -235,13 +245,15 @@ static void complt_home_dir(ToxWindow *self, char *path, int pathsize, const cha
 
     wchar_t wline[MAX_STR_SIZE];
 
-    if (mbs_to_wcs_buf(wline, newline, sizeof(wline) / sizeof(wchar_t)) == -1)
+    if (mbs_to_wcs_buf(wline, newline, sizeof(wline) / sizeof(wchar_t)) == -1) {
         return;
+    }
 
     int newlen = wcslen(wline);
 
-    if (ctx->len + newlen >= MAX_STR_SIZE)
+    if (ctx->len + newlen >= MAX_STR_SIZE) {
         return;
+    }
 
     wmemcpy(ctx->line, wline, newlen + 1);
     ctx->pos = newlen;
@@ -261,14 +273,17 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
     char b_cmd[MAX_STR_SIZE];
     const wchar_t *tmpline = &line[wcslen(cmd) + 2];   /* start after "/command \"" */
 
-    if (wcs_to_mbs_buf(b_path, tmpline, sizeof(b_path)) == -1)
+    if (wcs_to_mbs_buf(b_path, tmpline, sizeof(b_path)) == -1) {
         return -1;
+    }
 
-    if (wcs_to_mbs_buf(b_cmd, cmd, sizeof(b_cmd)) == -1)
+    if (wcs_to_mbs_buf(b_cmd, cmd, sizeof(b_cmd)) == -1) {
         return -1;
+    }
 
-    if (b_path[0] == '~')
+    if (b_path[0] == '~') {
         complt_home_dir(self, b_path, sizeof(b_path), b_cmd, strlen(b_cmd) + 2);
+    }
 
     int si = char_rfind(b_path, '/', strlen(b_path));
 
@@ -286,8 +301,9 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
     int b_name_len = strlen(b_name);
     DIR *dp = opendir(b_path);
 
-    if (dp == NULL)
+    if (dp == NULL) {
         return -1;
+    }
 
     char dirnames[MAX_DIRS][NAME_MAX + 1];
     struct dirent *entry;
@@ -303,8 +319,9 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
 
     closedir(dp);
 
-    if (dircount == 0)
+    if (dircount == 0) {
         return -1;
+    }
 
     if (dircount > 1) {
         qsort(dirnames, dircount, NAME_MAX + 1, qsort_strcasecmp_hlpr);
diff --git a/src/avatars.c b/src/avatars.c
index 8d01f36..dba0a51 100644
--- a/src/avatars.c
+++ b/src/avatars.c
@@ -56,8 +56,9 @@ int avatar_send(Tox *m, uint32_t friendnum)
     uint32_t filenum = tox_file_send(m, friendnum, TOX_FILE_KIND_AVATAR, (size_t) Avatar.size,
                                      NULL, (uint8_t *) Avatar.name, Avatar.name_len, &err);
 
-    if (Avatar.size == 0)
+    if (Avatar.size == 0) {
         return 0;
+    }
 
     if (err != TOX_ERR_FILE_SEND_OK) {
         fprintf(stderr, "tox_file_send failed for friendnumber %d (error %d)\n", friendnum, err);
@@ -66,13 +67,15 @@ int avatar_send(Tox *m, uint32_t friendnum)
 
     struct FileTransfer *ft = new_file_transfer(NULL, friendnum, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_AVATAR);
 
-    if (!ft)
+    if (!ft) {
         return -1;
+    }
 
     ft->file = fopen(Avatar.path, "r");
 
-    if (ft->file == NULL)
+    if (ft->file == NULL) {
         return -1;
+    }
 
     snprintf(ft->file_name, sizeof(ft->file_name), "%s", Avatar.name);
     ft->file_size = Avatar.size;
@@ -86,8 +89,9 @@ static void avatar_send_all(Tox *m)
     size_t i;
 
     for (i = 0; i < Friends.max_idx; ++i) {
-        if (Friends.list[i].connection_status != TOX_CONNECTION_NONE)
+        if (Friends.list[i].connection_status != TOX_CONNECTION_NONE) {
             avatar_send(m, Friends.list[i].num);
+        }
     }
 }
 
@@ -98,13 +102,15 @@ static void avatar_send_all(Tox *m)
  */
 int avatar_set(Tox *m, const char *path, size_t path_len)
 {
-    if (path_len == 0 || path_len >= sizeof(Avatar.path))
+    if (path_len == 0 || path_len >= sizeof(Avatar.path)) {
         return -1;
+    }
 
     FILE *fp = fopen(path, "rb");
 
-    if (fp == NULL)
+    if (fp == NULL) {
         return -1;
+    }
 
     char PNG_signature[8] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};
 
@@ -117,8 +123,9 @@ int avatar_set(Tox *m, const char *path, size_t path_len)
 
     off_t size = file_size(path);
 
-    if (size == 0 || size > MAX_AVATAR_FILE_SIZE)
+    if (size == 0 || size > MAX_AVATAR_FILE_SIZE) {
         return -1;
+    }
 
     get_file_name(Avatar.name, sizeof(Avatar.name), path);
     Avatar.name_len = strlen(Avatar.name);
@@ -166,8 +173,9 @@ void on_avatar_file_control(Tox *m, struct FileTransfer *ft, TOX_FILE_CONTROL co
 
 void on_avatar_chunk_request(Tox *m, struct FileTransfer *ft, uint64_t position, size_t length)
 {
-    if (ft->state != FILE_TRANSFER_STARTED)
+    if (ft->state != FILE_TRANSFER_STARTED) {
         return;
+    }
 
     if (length == 0) {
         close_file_transfer(NULL, m, ft, -1, NULL, silent);
@@ -199,8 +207,9 @@ void on_avatar_chunk_request(Tox *m, struct FileTransfer *ft, uint64_t position,
     TOX_ERR_FILE_SEND_CHUNK err;
     tox_file_send_chunk(m, ft->friendnum, ft->filenum, position, send_data, send_length, &err);
 
-    if (err != TOX_ERR_FILE_SEND_CHUNK_OK)
+    if (err != TOX_ERR_FILE_SEND_CHUNK_OK) {
         fprintf(stderr, "tox_file_send_chunk failed in avatar callback (error %d)\n", err);
+    }
 
     ft->position += send_length;
     ft->last_keep_alive = get_unix_time();
diff --git a/src/chat.c b/src/chat.c
index ede1909..422ad8b 100644
--- a/src/chat.c
+++ b/src/chat.c
@@ -132,8 +132,9 @@ static const char chat_cmd_list[AC_NUM_CHAT_COMMANDS][MAX_CMDNAME_SIZE] = {
 
 static void set_self_typingstatus(ToxWindow *self, Tox *m, bool is_typing)
 {
-    if (user_settings->show_typing_self == SHOW_TYPING_OFF)
+    if (user_settings->show_typing_self == SHOW_TYPING_OFF) {
         return;
+    }
 
     ChatContext *ctx = self->chatwin;
 
@@ -197,16 +198,17 @@ static void recv_action_helper(ToxWindow *self, Tox *m, uint32_t num, const char
 
     if (self->active_box != -1)
         box_notify2(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
-                    self->active_box, "* %s %s", nick, action );
+                    self->active_box, "* %s %s", nick, action);
     else
         box_notify(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
-                   &self->active_box, self->name, "* %s %s", nick, action );
+                   &self->active_box, self->name, "* %s %s", nick, action);
 }
 
 static void chat_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TYPE type, const char *msg, size_t len)
 {
-    if (self->num != num)
+    if (self->num != num) {
         return;
+    }
 
     char nick[TOX_MAX_NAME_LENGTH];
     get_nick_truncate(m, nick, num);
@@ -214,11 +216,13 @@ static void chat_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TY
     char timefrmt[TIME_STR_SIZE];
     get_time_str(timefrmt, sizeof(timefrmt));
 
-    if (type == TOX_MESSAGE_TYPE_NORMAL)
+    if (type == TOX_MESSAGE_TYPE_NORMAL) {
         return recv_message_helper(self, m, num, msg, len, nick, timefrmt);
+    }
 
-    if (type == TOX_MESSAGE_TYPE_ACTION)
+    if (type == TOX_MESSAGE_TYPE_ACTION) {
         return recv_action_helper(self, m, num, msg, len, nick, timefrmt);
+    }
 }
 
 static void chat_pause_file_transfers(Tox *m, uint32_t friendnum);
@@ -226,8 +230,9 @@ static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t fnum);
 
 static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_CONNECTION connection_status)
 {
-    if (self->num != num)
+    if (self->num != num) {
         return;
+    }
 
     StatusBar *statusbar = self->stb;
     ChatContext *ctx = self->chatwin;
@@ -255,8 +260,9 @@ static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_C
     } else if (connection_status == TOX_CONNECTION_NONE) {
         Friends.list[num].is_typing = false;
 
-        if (self->chatwin->self_is_typing)
+        if (self->chatwin->self_is_typing) {
             set_self_typingstatus(self, m, 0);
+        }
 
         chat_pause_file_transfers(m, num);
 
@@ -268,16 +274,18 @@ static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_C
 
 static void chat_onTypingChange(ToxWindow *self, Tox *m, uint32_t num, bool is_typing)
 {
-    if (self->num != num)
+    if (self->num != num) {
         return;
+    }
 
     Friends.list[num].is_typing = is_typing;
 }
 
 static void chat_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const char *nick, size_t length)
 {
-    if (self->num != num)
+    if (self->num != num) {
         return;
+    }
 
     StatusBar *statusbar = self->stb;
 
@@ -290,8 +298,9 @@ static void chat_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const char
 
 static void chat_onStatusChange(ToxWindow *self, Tox *m, uint32_t num, TOX_USER_STATUS status)
 {
-    if (self->num != num)
+    if (self->num != num) {
         return;
+    }
 
     StatusBar *statusbar = self->stb;
     statusbar->status = status;
@@ -299,8 +308,9 @@ static void chat_onStatusChange(ToxWindow *self, Tox *m, uint32_t num, TOX_USER_
 
 static void chat_onStatusMessageChange(ToxWindow *self, uint32_t num, const char *status, size_t length)
 {
-    if (self->num != num)
+    if (self->num != num) {
         return;
+    }
 
     StatusBar *statusbar = self->stb;
 
@@ -321,11 +331,13 @@ static void chat_pause_file_transfers(Tox *m, uint32_t friendnum)
     size_t i;
 
     for (i = 0; i < MAX_FILES; ++i) {
-        if (friend->file_sender[i].state >= FILE_TRANSFER_STARTED)
+        if (friend->file_sender[i].state >= FILE_TRANSFER_STARTED) {
             friend->file_sender[i].state = FILE_TRANSFER_PAUSED;
+        }
 
-        if (friend->file_receiver[i].state >= FILE_TRANSFER_STARTED)
+        if (friend->file_receiver[i].state >= FILE_TRANSFER_STARTED) {
             friend->file_receiver[i].state = FILE_TRANSFER_PAUSED;
+        }
     }
 }
 
@@ -337,8 +349,9 @@ static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t friendnum
     for (i = 0; i < MAX_FILES; ++i) {
         struct FileTransfer *ft = &Friends.list[friendnum].file_sender[i];
 
-        if (ft->state != FILE_TRANSFER_PAUSED)
+        if (ft->state != FILE_TRANSFER_PAUSED) {
             continue;
+        }
 
         TOX_ERR_FILE_SEND err;
         ft->filenum = tox_file_send(m, friendnum, TOX_FILE_KIND_DATA, ft->file_size, ft->file_id,
@@ -356,16 +369,19 @@ static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t friendnum
 static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t position,
                                     size_t length)
 {
-    if (friendnum != self->num)
+    if (friendnum != self->num) {
         return;
+    }
 
     struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
 
-    if (!ft)
+    if (!ft) {
         return;
+    }
 
-    if (ft->state != FILE_TRANSFER_STARTED)
+    if (ft->state != FILE_TRANSFER_STARTED) {
         return;
+    }
 
     char msg[MAX_STR_SIZE];
 
@@ -404,8 +420,9 @@ static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t friendnum,
     TOX_ERR_FILE_SEND_CHUNK err;
     tox_file_send_chunk(m, ft->friendnum, ft->filenum, position, send_data, send_length, &err);
 
-    if (err != TOX_ERR_FILE_SEND_CHUNK_OK)
+    if (err != TOX_ERR_FILE_SEND_CHUNK_OK) {
         fprintf(stderr, "tox_file_send_chunk failed in chat callback (error %d)\n", err);
+    }
 
     ft->position += send_length;
     ft->bps += send_length;
@@ -415,16 +432,19 @@ static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t friendnum,
 static void chat_onFileRecvChunk(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t position,
                                  const char *data, size_t length)
 {
-    if (friendnum != self->num)
+    if (friendnum != self->num) {
         return;
+    }
 
     struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
 
-    if (!ft)
+    if (!ft) {
         return;
+    }
 
-    if (ft->state != FILE_TRANSFER_STARTED)
+    if (ft->state != FILE_TRANSFER_STARTED) {
         return;
+    }
 
     char msg[MAX_STR_SIZE];
 
@@ -454,13 +474,15 @@ static void chat_onFileRecvChunk(ToxWindow *self, Tox *m, uint32_t friendnum, ui
 
 static void chat_onFileControl(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, TOX_FILE_CONTROL control)
 {
-    if (friendnum != self->num)
+    if (friendnum != self->num) {
         return;
+    }
 
     struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
 
-    if (!ft)
+    if (!ft) {
         return;
+    }
 
     char msg[MAX_STR_SIZE];
 
@@ -507,8 +529,9 @@ static bool chat_resume_broken_ft(ToxWindow *self, Tox *m, uint32_t friendnum, u
     char msg[MAX_STR_SIZE];
     uint8_t file_id[TOX_FILE_ID_LENGTH];
 
-    if (!tox_file_get_file_id(m, friendnum, filenum, file_id, NULL))
+    if (!tox_file_get_file_id(m, friendnum, filenum, file_id, NULL)) {
         return false;
+    }
 
     bool resuming = false;
     struct FileTransfer *ft = NULL;
@@ -517,8 +540,9 @@ static bool chat_resume_broken_ft(ToxWindow *self, Tox *m, uint32_t friendnum, u
     for (i = 0; i < MAX_FILES; ++i) {
         ft = &Friends.list[friendnum].file_receiver[i];
 
-        if (ft->state == FILE_TRANSFER_INACTIVE)
+        if (ft->state == FILE_TRANSFER_INACTIVE) {
             continue;
+        }
 
         if (memcmp(ft->file_id, file_id, TOX_FILE_ID_LENGTH) == 0) {
             ft->filenum = filenum;
@@ -529,14 +553,17 @@ static bool chat_resume_broken_ft(ToxWindow *self, Tox *m, uint32_t friendnum, u
         }
     }
 
-    if (!resuming || !ft)
+    if (!resuming || !ft) {
         return false;
+    }
 
-    if (!tox_file_seek(m, ft->friendnum, ft->filenum, ft->position, NULL))
+    if (!tox_file_seek(m, ft->friendnum, ft->filenum, ft->position, NULL)) {
         goto on_error;
+    }
 
-    if (!tox_file_control(m, ft->friendnum, ft->filenum, TOX_FILE_CONTROL_RESUME, NULL))
+    if (!tox_file_control(m, ft->friendnum, ft->filenum, TOX_FILE_CONTROL_RESUME, NULL)) {
         goto on_error;
+    }
 
     return true;
 
@@ -549,12 +576,14 @@ on_error:
 static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t file_size,
                             const char *filename, size_t name_length)
 {
-    if (self->num != friendnum)
+    if (self->num != friendnum) {
         return;
+    }
 
     /* first check if we need to resume a broken transfer */
-    if (chat_resume_broken_ft(self, m, friendnum, filenum))
+    if (chat_resume_broken_ft(self, m, friendnum, filenum)) {
         return;
+    }
 
     struct FileTransfer *ft = new_file_transfer(self, friendnum, filenum, FILE_TRANSFER_RECV, TOX_FILE_KIND_DATA);
 
@@ -621,25 +650,28 @@ static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_
 
     if (self->active_box != -1)
         box_notify2(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS | user_settings->bell_on_filetrans,
-                    self->active_box, "Incoming file: %s", filename );
+                    self->active_box, "Incoming file: %s", filename);
     else
         box_notify(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS | user_settings->bell_on_filetrans,
-                   &self->active_box, self->name, "Incoming file: %s", filename );
+                   &self->active_box, self->name, "Incoming file: %s", filename);
 }
 
 static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, uint8_t type, const char *group_pub_key,
                                uint16_t length)
 {
-    if (self->num != friendnumber)
+    if (self->num != friendnumber) {
         return;
+    }
 
-    if (Friends.list[friendnumber].group_invite.key != NULL)
+    if (Friends.list[friendnumber].group_invite.key != NULL) {
         free(Friends.list[friendnumber].group_invite.key);
+    }
 
     char *k = malloc(length);
 
-    if (k == NULL)
+    if (k == NULL) {
         exit_toxic_err("Failed in chat_onGroupInvite", FATALERR_MEMORY);
+    }
 
     memcpy(k, group_pub_key, length);
     Friends.list[friendnumber].group_invite.key = k;
@@ -652,10 +684,11 @@ static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, ui
     char name[TOX_MAX_NAME_LENGTH];
     get_nick_truncate(m, name, friendnumber);
 
-    if (self->active_box != -1)
+    if (self->active_box != -1) {
         box_silent_notify2(self, NT_WNDALERT_2 | NT_NOFOCUS, self->active_box, "invites you to join group chat");
-    else
+    } else {
         box_silent_notify(self, NT_WNDALERT_2 | NT_NOFOCUS, &self->active_box, name, "invites you to join group chat");
+    }
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s has invited you to a group chat.", name);
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Type \"/join\" to join the chat.");
@@ -664,44 +697,50 @@ static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, ui
 /* AV Stuff */
 #ifdef AUDIO
 
-void chat_onInvite (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onInvite(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     /* call is flagged active here */
     self->is_call = true;
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Incoming audio call! Type: \"/answer\" or \"/reject\"");
 
-    if (self->ringing_sound == -1)
+    if (self->ringing_sound == -1) {
         sound_notify(self, call_incoming, NT_LOOP | user_settings->bell_on_invite, &self->ringing_sound);
+    }
 
-    if (self->active_box != -1)
+    if (self->active_box != -1) {
         box_silent_notify2(self, NT_NOFOCUS | NT_WNDALERT_0, self->active_box, "Incoming audio call!");
-    else
+    } else {
         box_silent_notify(self, NT_NOFOCUS | NT_WNDALERT_0, &self->active_box, self->name, "Incoming audio call!");
+    }
 }
 
-void chat_onRinging (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onRinging(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Ringing...type \"/hangup\" to cancel it.");
 
 #ifdef SOUND_NOTIFY
 
-    if (self->ringing_sound == -1)
+    if (self->ringing_sound == -1) {
         sound_notify(self, call_outgoing, NT_LOOP, &self->ringing_sound);
+    }
 
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onStarting (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onStarting(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     init_infobox(self);
 
@@ -715,10 +754,11 @@ void chat_onStarting (ToxWindow *self, ToxAV *av, uint32_t friend_number, int st
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onEnding (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onEnding(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     kill_infobox(self);
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call ended!");
@@ -730,10 +770,11 @@ void chat_onEnding (ToxWindow *self, ToxAV *av, uint32_t friend_number, int stat
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onError (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onError(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     self->is_call = false;
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Error!");
@@ -743,10 +784,11 @@ void chat_onError (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onStart (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onStart(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     /* call is flagged active here */
     self->is_call = true;
@@ -760,10 +802,11 @@ void chat_onStart (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onCancel (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onCancel(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     self->is_call = false;
     kill_infobox(self);
@@ -774,10 +817,11 @@ void chat_onCancel (ToxWindow *self, ToxAV *av, uint32_t friend_number, int stat
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onReject (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onReject(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self  || self->num != friend_number)
+    if (!self  || self->num != friend_number) {
         return;
+    }
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Rejected!");
     self->is_call = false;
@@ -787,10 +831,11 @@ void chat_onReject (ToxWindow *self, ToxAV *av, uint32_t friend_number, int stat
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onEnd (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
+void chat_onEnd(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != friend_number)
+    if (!self || self->num != friend_number) {
         return;
+    }
 
     kill_infobox(self);
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call ended!");
@@ -808,8 +853,9 @@ static void init_infobox(ToxWindow *self)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         return;
+    }
 
     (void) y2;
 
@@ -826,8 +872,9 @@ static void kill_infobox(ToxWindow *self)
 {
     ChatContext *ctx = self->chatwin;
 
-    if (!ctx->infobox.win)
+    if (!ctx->infobox.win) {
         return;
+    }
 
     delwin(ctx->infobox.win);
     memset(&ctx->infobox, 0, sizeof(struct infobox));
@@ -838,20 +885,23 @@ static void draw_infobox(ToxWindow *self)
 {
     struct infobox *infobox = &self->chatwin->infobox;
 
-    if (infobox->win == NULL)
+    if (infobox->win == NULL) {
         return;
+    }
 
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (x2 < INFOBOX_WIDTH || y2 < INFOBOX_HEIGHT)
+    if (x2 < INFOBOX_WIDTH || y2 < INFOBOX_HEIGHT) {
         return;
+    }
 
     time_t curtime = get_unix_time();
 
     /* update elapsed time string once per second */
-    if (curtime > infobox->lastupdate)
+    if (curtime > infobox->lastupdate) {
         get_elapsed_time_str(infobox->timestr, sizeof(infobox->timestr), curtime - infobox->starttime);
+    }
 
     infobox->lastupdate = curtime;
 
@@ -891,8 +941,9 @@ static void draw_infobox(ToxWindow *self)
 
 static void send_action(ToxWindow *self, ChatContext *ctx, Tox *m, char *action)
 {
-    if (action == NULL)
+    if (action == NULL) {
         return;
+    }
 
     char selfname[TOX_MAX_NAME_LENGTH];
     tox_self_get_name(m, (uint8_t *) selfname);
@@ -916,11 +967,13 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     getyx(self->window, y, x);
     getmaxyx(self->window, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         return;
+    }
 
-    if (ctx->pastemode && key == '\r')
+    if (ctx->pastemode && key == '\r') {
         key = '\n';
+    }
 
     if (self->help->active) {
         help_onKey(self, key);
@@ -930,14 +983,16 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     if (ltr || key == '\n') {    /* char is printable */
         input_new_char(self, key, x, y, x2, y2);
 
-        if (ctx->line[0] != '/' && !ctx->self_is_typing && statusbar->connection != TOX_CONNECTION_NONE)
+        if (ctx->line[0] != '/' && !ctx->self_is_typing && statusbar->connection != TOX_CONNECTION_NONE) {
             set_self_typingstatus(self, m, 1);
+        }
 
         return;
     }
 
-    if (line_info_onKey(self, key))
+    if (line_info_onKey(self, key)) {
         return;
+    }
 
     input_handle(self, key, x, y, x2, y2);
 
@@ -988,8 +1043,9 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 
             char line[MAX_STR_SIZE] = {0};
 
-            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
+            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1) {
                 memset(&line, 0, sizeof(line));
+            }
 
             if (line[0] == '/') {
                 if (strcmp(line, "/close") == 0) {
@@ -1020,8 +1076,9 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
         reset_buf(ctx);
     }
 
-    if (ctx->len <= 0 && ctx->self_is_typing)
+    if (ctx->len <= 0 && ctx->self_is_typing) {
         set_self_typingstatus(self, m, 0);
+    }
 }
 
 static void chat_onDraw(ToxWindow *self, Tox *m)
@@ -1029,8 +1086,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         return;
+    }
 
     ChatContext *ctx = self->chatwin;
 
@@ -1042,8 +1100,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
 
     curs_set(1);
 
-    if (ctx->len > 0)
+    if (ctx->len > 0) {
         mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
+    }
 
     /* Draw status bar */
     StatusBar *statusbar = self->stb;
@@ -1073,15 +1132,17 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
         wprintw(statusbar->topline, " %s", ONLINE_CHAR);
         wattroff(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
 
-        if (Friends.list[self->num].is_typing)
+        if (Friends.list[self->num].is_typing) {
             wattron(statusbar->topline, COLOR_PAIR(YELLOW));
+        }
 
         wattron(statusbar->topline, A_BOLD);
         wprintw(statusbar->topline, " %s ", statusbar->nick);
         wattroff(statusbar->topline, A_BOLD);
 
-        if (Friends.list[self->num].is_typing)
+        if (Friends.list[self->num].is_typing) {
             wattroff(statusbar->topline, COLOR_PAIR(YELLOW));
+        }
     } else {
         wprintw(statusbar->topline, " %s", OFFLINE_CHAR);
         wattron(statusbar->topline, A_BOLD);
@@ -1114,8 +1175,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
         statusbar->statusmsg_len = maxlen;
     }
 
-    if (statusbar->statusmsg[0])
+    if (statusbar->statusmsg[0]) {
         wprintw(statusbar->topline, ": %s ", statusbar->statusmsg);
+    }
 
     wclrtoeol(statusbar->topline);
     wmove(statusbar->topline, 0, x2 - (KEY_IDENT_DIGITS * 2) - 3);
@@ -1123,8 +1185,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
 
     size_t i;
 
-    for (i = 0; i < KEY_IDENT_DIGITS; ++i)
+    for (i = 0; i < KEY_IDENT_DIGITS; ++i) {
         wprintw(statusbar->topline, "%02X", Friends.list[self->num].pub_key[i] & 0xff);
+    }
 
     wprintw(statusbar->topline, "}\n");
 
@@ -1146,8 +1209,9 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
 
 #endif
 
-    if (self->help->active)
+    if (self->help->active) {
         help_onDraw(self);
+    }
 
     pthread_mutex_lock(&Winthread.lock);
     refresh_file_transfer_progress(self, m, self->num);
@@ -1160,8 +1224,9 @@ static void chat_onInit(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         exit_toxic_err("failed in chat_onInit", FATALERR_CURSES);
+    }
 
     self->x = x2;
 
@@ -1196,8 +1261,9 @@ static void chat_onInit(ToxWindow *self, Tox *m)
     ctx->log = calloc(1, sizeof(struct chatlog));
     ctx->cqueue = calloc(1, sizeof(struct chat_queue));
 
-    if (ctx->log == NULL || ctx->hst == NULL || ctx->cqueue == NULL)
+    if (ctx->log == NULL || ctx->hst == NULL || ctx->cqueue == NULL) {
         exit_toxic_err("failed in chat_onInit", FATALERR_MEMORY);
+    }
 
     line_info_init(ctx->hst);
 
@@ -1207,10 +1273,11 @@ static void chat_onInit(ToxWindow *self, Tox *m)
     int log_ret = log_enable(nick, myid, Friends.list[self->num].pub_key, ctx->log, LOG_CHAT);
     load_chat_history(self, ctx->log);
 
-    if (!Friends.list[self->num].logging_on)
+    if (!Friends.list[self->num].logging_on) {
         log_disable(ctx->log);
-    else if (log_ret == -1)
+    } else if (log_ret == -1) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
+    }
 
     execute(ctx->history, self, m, "/log", GLOBAL_COMMAND_MODE);
 
@@ -1268,8 +1335,9 @@ ToxWindow new_chat(Tox *m, uint32_t friendnum)
     StatusBar *stb = calloc(1, sizeof(StatusBar));
     Help *help = calloc(1, sizeof(Help));
 
-    if (stb == NULL || chatwin == NULL || help == NULL)
+    if (stb == NULL || chatwin == NULL || help == NULL) {
         exit_toxic_err("failed in new_chat", FATALERR_MEMORY);
+    }
 
     ret.chatwin = chatwin;
     ret.stb = stb;
diff --git a/src/chat_commands.c b/src/chat_commands.c
index 52eb8bf..2d0ebe9 100644
--- a/src/chat_commands.c
+++ b/src/chat_commands.c
@@ -175,8 +175,9 @@ void cmd_savefile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
     TOX_ERR_FILE_CONTROL err;
     tox_file_control(m, self->num, ft->filenum, TOX_FILE_CONTROL_RESUME, &err);
 
-    if (err != TOX_ERR_FILE_CONTROL_OK)
+    if (err != TOX_ERR_FILE_CONTROL_OK) {
         goto on_recv_error;
+    }
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Saving file [%d] as: '%s'", idx, ft->file_path);
 
@@ -262,8 +263,9 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
     uint32_t filenum = tox_file_send(m, self->num, TOX_FILE_KIND_DATA, (uint64_t) filesize, NULL,
                                      (uint8_t *) file_name, namelen, &err);
 
-    if (err != TOX_ERR_FILE_SEND_OK)
+    if (err != TOX_ERR_FILE_SEND_OK) {
         goto on_send_error;
+    }
 
     struct FileTransfer *ft = new_file_transfer(self, self->num, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_DATA);
 
diff --git a/src/configdir.c b/src/configdir.c
index ee97af3..8d69dc6 100644
--- a/src/configdir.c
+++ b/src/configdir.c
@@ -48,8 +48,9 @@ void get_home_dir(char *home, int size)
     } else {
         hmstr = getenv("HOME");
 
-        if (hmstr == NULL)
+        if (hmstr == NULL) {
             return;
+        }
 
         snprintf(buf, sizeof(buf), "%s", hmstr);
         hmstr = buf;
@@ -77,8 +78,9 @@ char *get_user_config_dir(void)
     len = strlen(home) + strlen("/Library/Application Support") + 1;
     user_config_dir = malloc(len);
 
-    if (user_config_dir == NULL)
+    if (user_config_dir == NULL) {
         return NULL;
+    }
 
     snprintf(user_config_dir, len, "%s/Library/Application Support", home);
 # else /* __APPLE__ */
@@ -89,8 +91,9 @@ char *get_user_config_dir(void)
         len = strlen(home) + strlen("/.config") + 1;
         user_config_dir = malloc(len);
 
-        if (user_config_dir == NULL)
+        if (user_config_dir == NULL) {
             return NULL;
+        }
 
         snprintf(user_config_dir, len, "%s/.config", home);
     } else {
@@ -112,14 +115,16 @@ int create_user_config_dirs(char *path)
     struct stat buf;
     int mkdir_err = mkdir(path, 0700);
 
-    if (mkdir_err && (errno != EEXIST || stat(path, &buf) || !S_ISDIR(buf.st_mode)))
+    if (mkdir_err && (errno != EEXIST || stat(path, &buf) || !S_ISDIR(buf.st_mode))) {
         return -1;
+    }
 
     char *fullpath = malloc(strlen(path) + strlen(CONFIGDIR) + 1);
     char *logpath = malloc(strlen(path) + strlen(LOGDIR) + 1);
 
-    if (fullpath == NULL || logpath == NULL)
+    if (fullpath == NULL || logpath == NULL) {
         exit_toxic_err("failed in load_data_structures", FATALERR_MEMORY);
+    }
 
     strcpy(fullpath, path);
     strcat(fullpath, CONFIGDIR);
diff --git a/src/curl_util.c b/src/curl_util.c
index 0678517..a184191 100644
--- a/src/curl_util.c
+++ b/src/curl_util.c
@@ -36,8 +36,9 @@
  */
 int set_curl_proxy(CURL *c_handle, const char *proxy_address, uint16_t port, uint8_t proxy_type)
 {
-    if (proxy_type == TOX_PROXY_TYPE_NONE)
+    if (proxy_type == TOX_PROXY_TYPE_NONE) {
         return 0;
+    }
 
     if (proxy_address == NULL || port == 0) {
         return -1;
diff --git a/src/execute.c b/src/execute.c
index f605cfd..b09cb96 100644
--- a/src/execute.c
+++ b/src/execute.c
@@ -113,8 +113,9 @@ static int parse_command(WINDOW *w, ToxWindow *self, const char *input, char (*a
 {
     char *cmd = strdup(input);
 
-    if (cmd == NULL)
+    if (cmd == NULL) {
         exit_toxic_err("failed in parse_command", FATALERR_MEMORY);
+    }
 
     int num_args = 0;
     int i = 0;    /* index of last char in an argument */
@@ -140,8 +141,9 @@ static int parse_command(WINDOW *w, ToxWindow *self, const char *input, char (*a
         memcpy(args[num_args], cmd, i + qt_ofst);
         args[num_args++][i + qt_ofst] = '\0';
 
-        if (cmd[i] == '\0')    /* no more args */
+        if (cmd[i] == '\0') {  /* no more args */
             break;
+        }
 
         char tmp[MAX_STR_SIZE];
         snprintf(tmp, sizeof(tmp), "%s", &cmd[i + 1]);
@@ -170,14 +172,16 @@ static int do_command(WINDOW *w, ToxWindow *self, Tox *m, int num_args, struct c
 
 void execute(WINDOW *w, ToxWindow *self, Tox *m, const char *input, int mode)
 {
-    if (string_is_empty(input))
+    if (string_is_empty(input)) {
         return;
+    }
 
     char args[MAX_NUM_ARGS][MAX_STR_SIZE];
     int num_args = parse_command(w, self, input, args);
 
-    if (num_args == -1)
+    if (num_args == -1) {
         return;
+    }
 
     /* Try to match input command to command functions. If non-global command mode is specified,
        try specified mode's commands first, then upon failure try global commands.
@@ -185,25 +189,29 @@ void execute(WINDOW *w, ToxWindow *self, Tox *m, const char *input, int mode)
        Note: Global commands must come last in case of duplicate command names */
     switch (mode) {
         case CHAT_COMMAND_MODE:
-            if (do_command(w, self, m, num_args, chat_commands, args) == 0)
+            if (do_command(w, self, m, num_args, chat_commands, args) == 0) {
                 return;
+            }
 
             break;
 
         case GROUPCHAT_COMMAND_MODE:
-            if (do_command(w, self, m, num_args, group_commands, args) == 0)
+            if (do_command(w, self, m, num_args, group_commands, args) == 0) {
                 return;
+            }
 
             break;
     }
 
-    if (do_command(w, self, m, num_args, global_commands, args) == 0)
+    if (do_command(w, self, m, num_args, global_commands, args) == 0) {
         return;
+    }
 
 #ifdef PYTHON
 
-    if (do_plugin_command(num_args, args) == 0)
+    if (do_plugin_command(num_args, args) == 0) {
         return;
+    }
 
 #endif
 
diff --git a/src/file_transfers.c b/src/file_transfers.c
index b15c9e7..73cb940 100644
--- a/src/file_transfers.c
+++ b/src/file_transfers.c
@@ -45,8 +45,9 @@ void init_progress_bar(char *progline)
     strcpy(progline, "0% [");
     int i;
 
-    for (i = 0; i < NUM_PROG_MARKS; ++i)
+    for (i = 0; i < NUM_PROG_MARKS; ++i) {
         strcat(progline, "-");
+    }
 
     strcat(progline, "] 0.0 B/s");
 }
@@ -54,8 +55,9 @@ void init_progress_bar(char *progline)
 /* prints a progress bar for file transfers. */
 void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t line_id)
 {
-    if (bps < 0 || pct_done < 0 || pct_done > 100)
+    if (bps < 0 || pct_done < 0 || pct_done > 100) {
         return;
+    }
 
     char pct_str[24];
     snprintf(pct_str, sizeof(pct_str), "%.1f%%", pct_done);
@@ -67,14 +69,17 @@ void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t l
     int n = pct_done / (100 / NUM_PROG_MARKS);
     int i, j;
 
-    for (i = 0; i < n; ++i)
+    for (i = 0; i < n; ++i) {
         strcat(prog_line, "=");
+    }
 
-    if (pct_done < 100)
+    if (pct_done < 100) {
         strcpy(prog_line + n, ">");
+    }
 
-    for (j = i; j < NUM_PROG_MARKS - 1; ++j)
+    for (j = i; j < NUM_PROG_MARKS - 1; ++j) {
         strcat(prog_line, "-");
+    }
 
     char full_line[strlen(pct_str) + NUM_PROG_MARKS + strlen(bps_str) + 7];
     snprintf(full_line, sizeof(full_line), "%s [%s] %s/s", pct_str, prog_line, bps_str);
@@ -84,12 +89,14 @@ void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t l
 
 static void refresh_progress_helper(ToxWindow *self, Tox *m, struct FileTransfer *ft)
 {
-    if (ft->state == FILE_TRANSFER_INACTIVE)
+    if (ft->state == FILE_TRANSFER_INACTIVE) {
         return;
+    }
 
     /* Timeout must be set to 1 second to show correct bytes per second */
-    if (!timed_out(ft->last_line_progress, 1))
+    if (!timed_out(ft->last_line_progress, 1)) {
         return;
+    }
 
     double remain = ft->file_size - ft->position;
     double pct_done = remain > 0 ? (1 - (remain / ft->file_size)) * 100 : 100;
@@ -120,13 +127,15 @@ struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filen
     for (i = 0; i < MAX_FILES; ++i) {
         struct FileTransfer *ft_send = &Friends.list[friendnum].file_sender[i];
 
-        if (ft_send->state != FILE_TRANSFER_INACTIVE && ft_send->filenum == filenum)
+        if (ft_send->state != FILE_TRANSFER_INACTIVE && ft_send->filenum == filenum) {
             return ft_send;
+        }
 
         struct FileTransfer *ft_recv = &Friends.list[friendnum].file_receiver[i];
 
-        if (ft_recv->state != FILE_TRANSFER_INACTIVE && ft_recv->filenum == filenum)
+        if (ft_recv->state != FILE_TRANSFER_INACTIVE && ft_recv->filenum == filenum) {
             return ft_recv;
+        }
     }
 
     return NULL;
@@ -138,8 +147,9 @@ struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filen
 struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t index,
         FILE_TRANSFER_DIRECTION direction)
 {
-    if (direction != FILE_TRANSFER_RECV && direction != FILE_TRANSFER_SEND)
+    if (direction != FILE_TRANSFER_RECV && direction != FILE_TRANSFER_SEND) {
         return NULL;
+    }
 
     size_t i;
 
@@ -148,8 +158,9 @@ struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t
                                       &Friends.list[friendnum].file_sender[i] :
                                       &Friends.list[friendnum].file_receiver[i];
 
-        if (ft->state != FILE_TRANSFER_INACTIVE && ft->index == index)
+        if (ft->state != FILE_TRANSFER_INACTIVE && ft->index == index) {
             return ft;
+        }
     }
 
     return NULL;
@@ -215,11 +226,13 @@ static struct FileTransfer *new_file_receiver(ToxWindow *window, uint32_t friend
 struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnum, uint32_t filenum,
                                        FILE_TRANSFER_DIRECTION direction, uint8_t type)
 {
-    if (direction == FILE_TRANSFER_RECV)
+    if (direction == FILE_TRANSFER_RECV) {
         return new_file_receiver(window, friendnum, filenum, type);
+    }
 
-    if (direction == FILE_TRANSFER_SEND)
+    if (direction == FILE_TRANSFER_SEND) {
         return new_file_sender(window, friendnum, filenum, type);
+    }
 
     return NULL;
 }
@@ -233,23 +246,28 @@ struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnum, ui
 void close_file_transfer(ToxWindow *self, Tox *m, struct FileTransfer *ft, int CTRL, const char *message,
                          Notification sound_type)
 {
-    if (!ft)
+    if (!ft) {
         return;
+    }
 
-    if (ft->state == FILE_TRANSFER_INACTIVE)
+    if (ft->state == FILE_TRANSFER_INACTIVE) {
         return;
+    }
 
-    if (ft->file)
+    if (ft->file) {
         fclose(ft->file);
+    }
 
-    if (CTRL >= 0)
+    if (CTRL >= 0) {
         tox_file_control(m, ft->friendnum, ft->filenum, (TOX_FILE_CONTROL) CTRL, NULL);
+    }
 
     if (message && self) {
-        if (self->active_box != -1 && sound_type != silent)
+        if (self->active_box != -1 && sound_type != silent) {
             box_notify2(self, sound_type, NT_NOFOCUS | NT_WNDALERT_2, self->active_box, "%s", message);
-        else
+        } else {
             box_notify(self, sound_type, NT_NOFOCUS | NT_WNDALERT_2, &self->active_box, self->name, "%s", message);
+        }
 
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", message);
     }
@@ -272,6 +290,7 @@ void kill_all_file_transfers(Tox *m)
 {
     size_t i;
 
-    for (i = 0; i < Friends.max_idx; ++i)
+    for (i = 0; i < Friends.max_idx; ++i) {
         kill_all_file_transfers_friend(m, Friends.list[i].num);
+    }
 }
diff --git a/src/friendlist.c b/src/friendlist.c
index 1765854..36f9b9b 100644
--- a/src/friendlist.c
+++ b/src/friendlist.c
@@ -84,8 +84,9 @@ static void realloc_friends(int n)
     ToxicFriend *f = realloc(Friends.list, n * sizeof(ToxicFriend));
     uint32_t *f_idx = realloc(Friends.index, n * sizeof(uint32_t));
 
-    if (f == NULL || f_idx == NULL)
+    if (f == NULL || f_idx == NULL) {
         exit_toxic_err("failed in realloc_friends", FATALERR_MEMORY);
+    }
 
     Friends.list = f;
     Friends.index = f_idx;
@@ -104,8 +105,9 @@ static void realloc_blocklist(int n)
     BlockedFriend *b = realloc(Blocked.list, n * sizeof(BlockedFriend));
     uint32_t *b_idx = realloc(Blocked.index, n * sizeof(uint32_t));
 
-    if (b == NULL || b_idx == NULL)
+    if (b == NULL || b_idx == NULL) {
         exit_toxic_err("failed in realloc_blocklist", FATALERR_MEMORY);
+    }
 
     Blocked.list = b;
     Blocked.index = b_idx;
@@ -116,8 +118,9 @@ void kill_friendlist(void)
     int i;
 
     for (i = 0; i < Friends.max_idx; ++i) {
-        if (Friends.list[i].active && Friends.list[i].group_invite.key != NULL)
+        if (Friends.list[i].active && Friends.list[i].group_invite.key != NULL) {
             free(Friends.list[i].group_invite.key);
+        }
     }
 
     realloc_blocklist(0);
@@ -215,13 +218,15 @@ static void sort_blocklist_index(void);
 
 int load_blocklist(char *path)
 {
-    if (path == NULL)
+    if (path == NULL) {
         return -1;
+    }
 
     FILE *fp = fopen(path, "rb");
 
-    if (fp == NULL)
+    if (fp == NULL) {
         return -1;
+    }
 
     off_t len = file_size(path);
 
@@ -298,8 +303,9 @@ void sort_friendlist_index(void)
     uint32_t n = 0;
 
     for (i = 0; i < Friends.max_idx; ++i) {
-        if (Friends.list[i].active)
+        if (Friends.list[i].active) {
             Friends.index[n++] = Friends.list[i].num;
+        }
     }
 
     qsort(Friends.index, Friends.num_friends, sizeof(uint32_t), index_name_cmp);
@@ -316,8 +322,9 @@ static void sort_blocklist_index(void)
     uint32_t n = 0;
 
     for (i = 0; i < Blocked.max_idx; ++i) {
-        if (Blocked.list[i].active)
+        if (Blocked.list[i].active) {
             Blocked.index[n++] = Blocked.list[i].num;
+        }
     }
 
     qsort(Blocked.index, Blocked.num_blocked, sizeof(uint32_t), index_name_cmp_block);
@@ -337,11 +344,13 @@ static void update_friend_last_online(uint32_t num, time_t timestamp)
 static void friendlist_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TYPE type, const char *str,
                                  size_t length)
 {
-    if (num >= Friends.max_idx)
+    if (num >= Friends.max_idx) {
         return;
+    }
 
-    if (Friends.list[num].chatwin != -1)
+    if (Friends.list[num].chatwin != -1) {
         return;
+    }
 
     if (get_num_active_windows() < MAX_WINDOWS_NUM) {
         Friends.list[num].chatwin = add_window(m, new_chat(m, Friends.list[num].num));
@@ -361,16 +370,18 @@ static void friendlist_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESS
 
 static void friendlist_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_CONNECTION connection_status)
 {
-    if (num >= Friends.max_idx)
+    if (num >= Friends.max_idx) {
         return;
+    }
 
     if (connection_status == TOX_CONNECTION_NONE) {
         --Friends.num_online;
     } else if (Friends.list[num].connection_status == TOX_CONNECTION_NONE) {
         ++Friends.num_online;
 
-        if (avatar_send(m, num) == -1)
+        if (avatar_send(m, num) == -1) {
             fprintf(stderr, "avatar_send failed for friend %d\n", num);
+        }
     }
 
     Friends.list[num].connection_status = connection_status;
@@ -381,8 +392,9 @@ static void friendlist_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num,
 
 static void friendlist_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const char *nick, size_t length)
 {
-    if (num >= Friends.max_idx)
+    if (num >= Friends.max_idx) {
         return;
+    }
 
     /* save old name for log renaming */
     char oldname[TOXIC_MAX_NAME_LENGTH + 1];
@@ -398,24 +410,27 @@ static void friendlist_onNickChange(ToxWindow *self, Tox *m, uint32_t num, const
     strcpy(newnamecpy, Friends.list[num].name);
     tox_self_get_address(m, (uint8_t *) myid);
 
-    if (strcmp(oldname, newnamecpy) != 0)
+    if (strcmp(oldname, newnamecpy) != 0) {
         rename_logfile(oldname, newnamecpy, myid, Friends.list[num].pub_key, Friends.list[num].chatwin);
+    }
 
     sort_friendlist_index();
 }
 
 static void friendlist_onStatusChange(ToxWindow *self, Tox *m, uint32_t num, TOX_USER_STATUS status)
 {
-    if (num >= Friends.max_idx)
+    if (num >= Friends.max_idx) {
         return;
+    }
 
     Friends.list[num].status = status;
 }
 
 static void friendlist_onStatusMessageChange(ToxWindow *self, uint32_t num, const char *note, size_t length)
 {
-    if (length > TOX_MAX_STATUS_MESSAGE_LENGTH || num >= Friends.max_idx)
+    if (length > TOX_MAX_STATUS_MESSAGE_LENGTH || num >= Friends.max_idx) {
         return;
+    }
 
     snprintf(Friends.list[num].statusmsg, sizeof(Friends.list[num].statusmsg), "%s", note);
     Friends.list[num].statusmsg_len = strlen(Friends.list[num].statusmsg);
@@ -429,8 +444,9 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
     uint32_t i;
 
     for (i = 0; i <= Friends.max_idx; ++i) {
-        if (Friends.list[i].active)
+        if (Friends.list[i].active) {
             continue;
+        }
 
         ++Friends.num_friends;
 
@@ -444,14 +460,16 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
         TOX_ERR_FRIEND_GET_PUBLIC_KEY pkerr;
         tox_friend_get_public_key(m, num, (uint8_t *) Friends.list[i].pub_key, &pkerr);
 
-        if (pkerr != TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK)
+        if (pkerr != TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK) {
             fprintf(stderr, "tox_friend_get_public_key failed (error %d)\n", pkerr);
+        }
 
         TOX_ERR_FRIEND_GET_LAST_ONLINE loerr;
         time_t t = tox_friend_get_last_online(m, num, &loerr);
 
-        if (loerr != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK)
+        if (loerr != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK) {
             t = 0;
+        }
 
         update_friend_last_online(i, t);
 
@@ -460,11 +478,13 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
         snprintf(Friends.list[i].name, sizeof(Friends.list[i].name), "%s", tempname);
         Friends.list[i].namelength = strlen(Friends.list[i].name);
 
-        if (i == Friends.max_idx)
+        if (i == Friends.max_idx) {
             ++Friends.max_idx;
+        }
 
-        if (sort)
+        if (sort) {
             sort_friendlist_index();
+        }
 
 #ifdef AUDIO
         init_friend_AV(i);
@@ -483,8 +503,9 @@ static void friendlist_add_blocked(Tox *m, uint32_t fnum, uint32_t bnum)
     int i;
 
     for (i = 0; i <= Friends.max_idx; ++i) {
-        if (Friends.list[i].active)
+        if (Friends.list[i].active) {
             continue;
+        }
 
         ++Friends.num_friends;
 
@@ -498,8 +519,9 @@ static void friendlist_add_blocked(Tox *m, uint32_t fnum, uint32_t bnum)
         memcpy(Friends.list[i].name, Blocked.list[bnum].name, Friends.list[i].namelength + 1);
         memcpy(Friends.list[i].pub_key, Blocked.list[bnum].pub_key, TOX_PUBLIC_KEY_SIZE);
 
-        if (i == Friends.max_idx)
+        if (i == Friends.max_idx) {
             ++Friends.max_idx;
+        }
 
         sort_blocklist_index();
         sort_friendlist_index();
@@ -511,11 +533,13 @@ static void friendlist_add_blocked(Tox *m, uint32_t fnum, uint32_t bnum)
 static void friendlist_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum,
                                   uint64_t file_size, const char *filename, size_t name_length)
 {
-    if (num >= Friends.max_idx)
+    if (num >= Friends.max_idx) {
         return;
+    }
 
-    if (Friends.list[num].chatwin != -1)
+    if (Friends.list[num].chatwin != -1) {
         return;
+    }
 
     if (get_num_active_windows() < MAX_WINDOWS_NUM) {
         Friends.list[num].chatwin = add_window(m, new_chat(m, Friends.list[num].num));
@@ -536,11 +560,13 @@ static void friendlist_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_
 static void friendlist_onGroupInvite(ToxWindow *self, Tox *m, int32_t num, uint8_t type, const char *group_pub_key,
                                      uint16_t length)
 {
-    if (num >= Friends.max_idx)
+    if (num >= Friends.max_idx) {
         return;
+    }
 
-    if (Friends.list[num].chatwin != -1)
+    if (Friends.list[num].chatwin != -1) {
         return;
+    }
 
     if (get_num_active_windows() < MAX_WINDOWS_NUM) {
         Friends.list[num].chatwin = add_window(m, new_chat(m, Friends.list[num].num));
@@ -559,12 +585,14 @@ static void friendlist_onGroupInvite(ToxWindow *self, Tox *m, int32_t num, uint8
 /* move friendlist/blocklist cursor up and down */
 static void select_friend(ToxWindow *self, wint_t key, int *selected, int num)
 {
-    if (num <= 0)
+    if (num <= 0) {
         return;
+    }
 
     if (key == KEY_UP) {
-        if (--(*selected) < 0)
+        if (--(*selected) < 0) {
             *selected = num - 1;
+        }
     } else if (key == KEY_DOWN) {
         *selected = (*selected + 1) % num;
     }
@@ -581,8 +609,9 @@ static void delete_friend(Tox *m, uint32_t f_num)
 
     --Friends.num_friends;
 
-    if (Friends.list[f_num].connection_status != TOX_CONNECTION_NONE)
+    if (Friends.list[f_num].connection_status != TOX_CONNECTION_NONE) {
         --Friends.num_online;
+    }
 
     /* close friend's chatwindow if it's currently open */
     if (Friends.list[f_num].chatwin >= 0) {
@@ -594,16 +623,18 @@ static void delete_friend(Tox *m, uint32_t f_num)
         }
     }
 
-    if (Friends.list[f_num].group_invite.key != NULL)
+    if (Friends.list[f_num].group_invite.key != NULL) {
         free(Friends.list[f_num].group_invite.key);
+    }
 
     memset(&Friends.list[f_num], 0, sizeof(ToxicFriend));
 
     int i;
 
     for (i = Friends.max_idx; i > 0; --i) {
-        if (Friends.list[i - 1].active)
+        if (Friends.list[i - 1].active) {
             break;
+        }
     }
 
     Friends.max_idx = i;
@@ -614,8 +645,9 @@ static void delete_friend(Tox *m, uint32_t f_num)
 #endif
 
     /* make sure num_selected stays within Friends.num_friends range */
-    if (Friends.num_friends && Friends.num_selected == Friends.num_friends)
+    if (Friends.num_friends && Friends.num_selected == Friends.num_friends) {
         --Friends.num_selected;
+    }
 
     store_data(m, DATA_FILE);
 }
@@ -651,8 +683,9 @@ static void del_friend_deactivate(ToxWindow *self, Tox *m, wint_t key)
 
 static void draw_del_popup(void)
 {
-    if (!PendingDelete.active)
+    if (!PendingDelete.active) {
         return;
+    }
 
     wattron(PendingDelete.popup, A_BOLD);
     box(PendingDelete.popup, ACS_VLINE, ACS_HLINE);
@@ -664,10 +697,11 @@ static void draw_del_popup(void)
 
     pthread_mutex_lock(&Winthread.lock);
 
-    if (blocklist_view == 0)
+    if (blocklist_view == 0) {
         wprintw(PendingDelete.popup, "%s", Friends.list[PendingDelete.num].name);
-    else
+    } else {
         wprintw(PendingDelete.popup, "%s", Blocked.list[PendingDelete.num].name);
+    }
 
     pthread_mutex_unlock(&Winthread.lock);
 
@@ -685,8 +719,9 @@ static void delete_blocked_friend(uint32_t bnum)
     int i;
 
     for (i = Blocked.max_idx; i > 0; --i) {
-        if (Blocked.list[i - 1].active)
+        if (Blocked.list[i - 1].active) {
             break;
+        }
     }
 
     --Blocked.num_blocked;
@@ -694,15 +729,17 @@ static void delete_blocked_friend(uint32_t bnum)
     realloc_blocklist(i);
     save_blocklist(BLOCK_FILE);
 
-    if (Blocked.num_blocked && Blocked.num_selected == Blocked.num_blocked)
+    if (Blocked.num_blocked && Blocked.num_selected == Blocked.num_blocked) {
         --Blocked.num_selected;
+    }
 }
 
 /* deletes contact from friendlist and puts in blocklist */
 void block_friend(Tox *m, uint32_t fnum)
 {
-    if (Friends.num_friends <= 0)
+    if (Friends.num_friends <= 0) {
         return;
+    }
 
     realloc_blocklist(Blocked.max_idx + 1);
     memset(&Blocked.list[Blocked.max_idx], 0, sizeof(BlockedFriend));
@@ -710,8 +747,9 @@ void block_friend(Tox *m, uint32_t fnum)
     int i;
 
     for (i = 0; i <= Blocked.max_idx; ++i) {
-        if (Blocked.list[i].active)
+        if (Blocked.list[i].active) {
             continue;
+        }
 
         Blocked.list[i].active = true;
         Blocked.list[i].num = i;
@@ -722,8 +760,9 @@ void block_friend(Tox *m, uint32_t fnum)
 
         ++Blocked.num_blocked;
 
-        if (i == Blocked.max_idx)
+        if (i == Blocked.max_idx) {
             ++Blocked.max_idx;
+        }
 
         delete_friend(m, fnum);
         save_blocklist(BLOCK_FILE);
@@ -737,8 +776,9 @@ void block_friend(Tox *m, uint32_t fnum)
 /* removes friend from blocklist, puts back in friendlist */
 static void unblock_friend(Tox *m, uint32_t bnum)
 {
-    if (Blocked.num_blocked <= 0)
+    if (Blocked.num_blocked <= 0) {
         return;
+    }
 
     TOX_ERR_FRIEND_ADD err;
     uint32_t friendnum = tox_friend_add_norequest(m, (uint8_t *) Blocked.list[bnum].pub_key, &err);
@@ -767,34 +807,40 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
         return;
     }
 
-    if (!blocklist_view && !Friends.num_friends && (key != KEY_RIGHT && key != KEY_LEFT))
+    if (!blocklist_view && !Friends.num_friends && (key != KEY_RIGHT && key != KEY_LEFT)) {
         return;
+    }
 
-    if (blocklist_view && !Blocked.num_blocked && (key != KEY_RIGHT && key != KEY_LEFT))
+    if (blocklist_view && !Blocked.num_blocked && (key != KEY_RIGHT && key != KEY_LEFT)) {
         return;
+    }
 
     int f = 0;
 
-    if (blocklist_view == 1 && Blocked.num_blocked)
+    if (blocklist_view == 1 && Blocked.num_blocked) {
         f = Blocked.index[Blocked.num_selected];
-    else if (Friends.num_friends)
+    } else if (Friends.num_friends) {
         f = Friends.index[Friends.num_selected];
+    }
 
     /* lock screen and force decision on deletion popup */
     if (PendingDelete.active) {
-        if (key == 'y' || key == 'n')
+        if (key == 'y' || key == 'n') {
             del_friend_deactivate(self, m, key);
+        }
 
         return;
     }
 
-    if (key == ltr)
+    if (key == ltr) {
         return;
+    }
 
     switch (key) {
         case '\r':
-            if (blocklist_view)
+            if (blocklist_view) {
                 break;
+            }
 
             /* Jump to chat window if already open */
             if (Friends.list[f].chatwin != -1) {
@@ -815,10 +861,11 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
             break;
 
         case 'b':
-            if (!blocklist_view)
+            if (!blocklist_view) {
                 block_friend(m, f);
-            else
+            } else {
                 unblock_friend(m, f);
+            }
 
             break;
 
@@ -828,10 +875,11 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
             break;
 
         default:
-            if (blocklist_view == 0)
+            if (blocklist_view == 0) {
                 select_friend(self, key, &Friends.num_selected, Friends.num_friends);
-            else
+            } else {
                 select_friend(self, key, &Blocked.num_selected, Blocked.num_blocked);
+            }
 
             break;
     }
@@ -846,8 +894,9 @@ static void blocklist_onDraw(ToxWindow *self, Tox *m, int y2, int x2)
     wattroff(self->window, A_BOLD);
     wprintw(self->window, "%d\n\n", Blocked.num_blocked);
 
-    if ((y2 - FLIST_OFST) <= 0)
+    if ((y2 - FLIST_OFST) <= 0) {
         return;
+    }
 
     uint32_t selected_num = 0;
 
@@ -876,15 +925,17 @@ static void blocklist_onDraw(ToxWindow *self, Tox *m, int y2, int x2)
         wprintw(self->window, "x");
         wattroff(self->window, COLOR_PAIR(RED));
 
-        if (f_selected)
+        if (f_selected) {
             wattron(self->window, COLOR_PAIR(BLUE));
+        }
 
         wattron(self->window, A_BOLD);
         wprintw(self->window, " %s\n", Blocked.list[f].name);
         wattroff(self->window, A_BOLD);
 
-        if (f_selected)
+        if (f_selected) {
             wattroff(self->window, COLOR_PAIR(BLUE));
+        }
     }
 
     wprintw(self->window, "\n");
@@ -899,15 +950,17 @@ static void blocklist_onDraw(ToxWindow *self, Tox *m, int y2, int x2)
 
         int i;
 
-        for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i)
+        for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i) {
             wprintw(self->window, "%02X", Blocked.list[selected_num].pub_key[i] & 0xff);
+        }
     }
 
     wnoutrefresh(self->window);
     draw_del_popup();
 
-    if (self->help->active)
+    if (self->help->active) {
         help_onDraw(self);
+    }
 }
 
 static void friendlist_onDraw(ToxWindow *self, Tox *m)
@@ -941,8 +994,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
 
     wprintw(self->window, "%d/%d \n\n", Friends.num_online, Friends.num_friends);
 
-    if ((y2 - FLIST_OFST) <= 0)
+    if ((y2 - FLIST_OFST) <= 0) {
         return;
+    }
 
     uint32_t selected_num = 0;
 
@@ -1006,8 +1060,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                 wprintw(self->window, "%s ", ONLINE_CHAR);
                 wattroff(self->window, COLOR_PAIR(colour) | A_BOLD);
 
-                if (f_selected)
+                if (f_selected) {
                     wattron(self->window, COLOR_PAIR(BLUE));
+                }
 
                 wattron(self->window, A_BOLD);
                 pthread_mutex_lock(&Winthread.lock);
@@ -1015,8 +1070,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                 pthread_mutex_unlock(&Winthread.lock);
                 wattroff(self->window, A_BOLD);
 
-                if (f_selected)
+                if (f_selected) {
                     wattroff(self->window, COLOR_PAIR(BLUE));
+                }
 
                 /* Reset Friends.list[f].statusmsg on window resize */
                 if (fix_statuses) {
@@ -1049,8 +1105,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                     Friends.list[f].statusmsg_len = maxlen;
                 }
 
-                if (Friends.list[f].statusmsg_len > 0)
+                if (Friends.list[f].statusmsg_len > 0) {
                     wprintw(self->window, " %s", Friends.list[f].statusmsg);
+                }
 
                 pthread_mutex_unlock(&Winthread.lock);
 
@@ -1058,8 +1115,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
             } else {
                 wprintw(self->window, "%s ", OFFLINE_CHAR);
 
-                if (f_selected)
+                if (f_selected) {
                     wattron(self->window, COLOR_PAIR(BLUE));
+                }
 
                 wattron(self->window, A_BOLD);
                 pthread_mutex_lock(&Winthread.lock);
@@ -1067,8 +1125,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                 pthread_mutex_unlock(&Winthread.lock);
                 wattroff(self->window, A_BOLD);
 
-                if (f_selected)
+                if (f_selected) {
                     wattroff(self->window, COLOR_PAIR(BLUE));
+                }
 
                 pthread_mutex_lock(&Winthread.lock);
                 time_t last_seen = Friends.list[f].last_online.last_on;
@@ -1116,15 +1175,17 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
 
         int i;
 
-        for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i)
+        for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i) {
             wprintw(self->window, "%02X", Friends.list[selected_num].pub_key[i] & 0xff);
+        }
     }
 
     wnoutrefresh(self->window);
     draw_del_popup();
 
-    if (self->help->active)
+    if (self->help->active) {
         help_onDraw(self);
+    }
 }
 
 void disable_chatwin(uint32_t f_num)
@@ -1137,8 +1198,9 @@ static void friendlist_onAV(ToxWindow *self, ToxAV *av, uint32_t friend_number,
 {
     assert(0);
 
-    if ( friend_number >= Friends.max_idx)
+    if (friend_number >= Friends.max_idx) {
         return;
+    }
 
     assert(0);
     Tox *m = toxav_get_tox(av);
@@ -1214,8 +1276,9 @@ ToxWindow new_friendlist(void)
 
     Help *help = calloc(1, sizeof(Help));
 
-    if (help == NULL)
+    if (help == NULL) {
         exit_toxic_err("failed in new_friendlist", FATALERR_MEMORY);
+    }
 
     ret.help = help;
     strcpy(ret.name, "contacts");
diff --git a/src/global_commands.c b/src/global_commands.c
index bcdfab7..ab5af86 100644
--- a/src/global_commands.c
+++ b/src/global_commands.c
@@ -79,8 +79,9 @@ void cmd_accept(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     int i;
 
     for (i = FrndRequests.max_idx; i > 0; --i) {
-        if (FrndRequests.request[i - 1].active)
+        if (FrndRequests.request[i - 1].active) {
             break;
+        }
     }
 
     FrndRequests.max_idx = i;
@@ -313,8 +314,9 @@ void cmd_decline(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
     int i;
 
     for (i = FrndRequests.max_idx; i > 0; --i) {
-        if (FrndRequests.request[i - 1].active)
+        if (FrndRequests.request[i - 1].active) {
             break;
+        }
     }
 
     FrndRequests.max_idx = i;
@@ -335,11 +337,11 @@ void cmd_groupchat(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*arg
 
     uint8_t type;
 
-    if (!strcasecmp(argv[1], "audio"))
+    if (!strcasecmp(argv[1], "audio")) {
         type = TOX_CONFERENCE_TYPE_AV;
-    else if (!strcasecmp(argv[1], "text"))
+    } else if (!strcasecmp(argv[1], "text")) {
         type = TOX_CONFERENCE_TYPE_TEXT;
-    else {
+    } else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Valid group types are: text | audio");
         return;
     }
@@ -373,10 +375,11 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
     struct chatlog *log = self->chatwin->log;
 
     if (argc == 0) {
-        if (log->log_on)
+        if (log->log_on) {
             msg = "Logging for this window is ON; type \"/log off\" to disable. (Logs are not encrypted)";
-        else
+        } else {
             msg = "Logging for this window is OFF; type \"/log on\" to enable.";
+        }
 
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
         return;
@@ -403,8 +406,9 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
         return;
     } else if (!strcmp(swch, "0") || !strcmp(swch, "off")) {
-        if (self->is_chat)
+        if (self->is_chat) {
             Friends.list[self->num].logging_on = false;
+        }
 
         log_disable(log);
 
@@ -592,8 +596,9 @@ void cmd_requests(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
     int count = 0;
 
     for (i = 0; i < FrndRequests.max_idx; ++i) {
-        if (!FrndRequests.request[i].active)
+        if (!FrndRequests.request[i].active) {
             continue;
+        }
 
         char id[TOX_PUBLIC_KEY_SIZE * 2 + 1] = {0};
 
@@ -606,8 +611,9 @@ void cmd_requests(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%d : %s", i, id);
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", FrndRequests.request[i].msg);
 
-        if (++count < FrndRequests.num_requests)
+        if (++count < FrndRequests.num_requests) {
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "");
+        }
     }
 }
 
@@ -616,7 +622,7 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     bool have_note = false;
     const char *errmsg;
 
-    lock_status ();
+    lock_status();
 
     if (argc >= 2) {
         have_note = true;
@@ -629,13 +635,13 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     const char *status_str = argv[1];
     TOX_USER_STATUS status;
 
-    if (!strcasecmp(status_str, "online"))
+    if (!strcasecmp(status_str, "online")) {
         status = TOX_USER_STATUS_NONE;
-    else if (!strcasecmp(status_str, "away"))
+    } else if (!strcasecmp(status_str, "away")) {
         status = TOX_USER_STATUS_AWAY;
-    else if (!strcasecmp(status_str, "busy"))
+    } else if (!strcasecmp(status_str, "busy")) {
         status = TOX_USER_STATUS_BUSY;
-    else {
+    } else {
         errmsg = "Invalid status. Valid statuses are: online, busy and away.";
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, errmsg);
         goto finish;
@@ -663,5 +669,5 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     }
 
 finish:
-    unlock_status ();
+    unlock_status();
 }
diff --git a/src/groupchat.c b/src/groupchat.c
index 85f4c96..36a7061 100644
--- a/src/groupchat.c
+++ b/src/groupchat.c
@@ -132,8 +132,9 @@ int init_groupchat_win(ToxWindow *prompt, Tox *m, uint32_t groupnum, uint8_t typ
 
             set_active_window(groupchats[i].chatwin);
 
-            if (i == max_groupchat_index)
+            if (i == max_groupchat_index) {
                 ++max_groupchat_index;
+            }
 
             return 0;
         }
@@ -166,8 +167,9 @@ void free_groupchat(ToxWindow *self, Tox *m, uint32_t groupnum)
     int i;
 
     for (i = max_groupchat_index; i > 0; --i) {
-        if (groupchats[i - 1].active)
+        if (groupchats[i - 1].active) {
             break;
+        }
     }
 
     max_groupchat_index = i;
@@ -193,8 +195,9 @@ void redraw_groupchat_win(ToxWindow *self)
     getmaxyx(stdscr, y2, x2);
     y2 -= 2;
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         return;
+    }
 
     if (ctx->sidebar) {
         delwin(ctx->sidebar);
@@ -222,8 +225,9 @@ void redraw_groupchat_win(ToxWindow *self)
 static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, uint32_t groupnum, uint32_t peernum,
                                      TOX_MESSAGE_TYPE type, const char *msg, size_t len)
 {
-    if (self->num != groupnum)
+    if (self->num != groupnum) {
         return;
+    }
 
     ChatContext *ctx = self->chatwin;
 
@@ -242,10 +246,11 @@ static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, uint32_t groupnum,
     if (strcasestr(msg, selfnick) && strcmp(selfnick, nick)) {
         sound_notify(self, generic_message, NT_WNDALERT_0 | user_settings->bell_on_message, NULL);
 
-        if (self->active_box != -1)
+        if (self->active_box != -1) {
             box_silent_notify2(self, NT_NOFOCUS, self->active_box, "%s %s", nick, msg);
-        else
+        } else {
             box_silent_notify(self, NT_NOFOCUS, &self->active_box, self->name, "%s %s", nick, msg);
+        }
 
         nick_clr = RED;
     } else {
@@ -265,8 +270,9 @@ static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, uint32_t group
 {
     ChatContext *ctx = self->chatwin;
 
-    if (self->num != groupnum)
+    if (self->num != groupnum) {
         return;
+    }
 
     set_window_title(self, title, length);
 
@@ -274,8 +280,9 @@ static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, uint32_t group
     get_time_str(timefrmt, sizeof(timefrmt));
 
     /* don't announce title when we join the room */
-    if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT))
+    if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT)) {
         return;
+    }
 
     char nick[TOX_MAX_NAME_LENGTH];
     get_group_nick_truncate(m, nick, peernum, groupnum);
@@ -383,11 +390,13 @@ static void update_peer_list(Tox *m, uint32_t groupnum, uint32_t num_peers)
 
 static void groupchat_onGroupNameListChange(ToxWindow *self, Tox *m, uint32_t groupnum)
 {
-    if (self->num != groupnum)
+    if (self->num != groupnum) {
         return;
+    }
 
-    if (groupnum > max_groupchat_index)
+    if (groupnum > max_groupchat_index) {
         return;
+    }
 
     GroupChat *chat = &groupchats[groupnum];
     TOX_ERR_CONFERENCE_PEER_QUERY err;
@@ -464,27 +473,31 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     getyx(self->window, y, x);
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= 0 || y2 <= 0)
+    if (x2 <= 0 || y2 <= 0) {
         return;
+    }
 
     if (self->help->active) {
         help_onKey(self, key);
         return;
     }
 
-    if (ctx->pastemode && key == '\r')
+    if (ctx->pastemode && key == '\r') {
         key = '\n';
+    }
 
     if (ltr || key == '\n') {    /* char is printable */
         input_new_char(self, key, x, y, x2, y2);
         return;
     }
 
-    if (line_info_onKey(self, key))
+    if (line_info_onKey(self, key)) {
         return;
+    }
 
-    if (input_handle(self, key, x, y, x2, y2))
+    if (input_handle(self, key, x, y, x2, y2)) {
         return;
+    }
 
     if (key == '\t') {  /* TAB key: auto-completes peer name or command */
         if (ctx->len > 0) {
@@ -523,11 +536,13 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     } else if (key == user_settings->key_peer_list_down) {    /* Scroll peerlist up and down one position */
         int L = y2 - CHATBOX_HEIGHT - SDBAR_OFST;
 
-        if (groupchats[self->num].side_pos < groupchats[self->num].num_peers - L)
+        if (groupchats[self->num].side_pos < groupchats[self->num].num_peers - L) {
             ++groupchats[self->num].side_pos;
+        }
     } else if (key == user_settings->key_peer_list_up) {
-        if (groupchats[self->num].side_pos > 0)
+        if (groupchats[self->num].side_pos > 0) {
             --groupchats[self->num].side_pos;
+        }
     } else if (key == '\r') {
         rm_trailing_spaces_buf(ctx);
 
@@ -538,8 +553,9 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 
             char line[MAX_STR_SIZE];
 
-            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
+            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1) {
                 memset(&line, 0, sizeof(line));
+            }
 
             if (line[0] == '/') {
                 if (strcmp(line, "/close") == 0) {
@@ -570,8 +586,9 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= 0 || y2 <= 0)
+    if (x2 <= 0 || y2 <= 0) {
         return;
+    }
 
     ChatContext *ctx = self->chatwin;
 
@@ -583,8 +600,9 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
 
     curs_set(1);
 
-    if (ctx->len > 0)
+    if (ctx->len > 0) {
         mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
+    }
 
     wclear(ctx->sidebar);
     mvwhline(self->window, y2 - CHATBOX_HEIGHT, 0, ACS_HLINE, x2);
@@ -637,8 +655,9 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
 
     wnoutrefresh(self->window);
 
-    if (self->help->active)
+    if (self->help->active) {
         help_onDraw(self);
+    }
 }
 
 static void groupchat_onInit(ToxWindow *self, Tox *m)
@@ -646,8 +665,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= 0 || y2 <= 0)
+    if (x2 <= 0 || y2 <= 0) {
         exit_toxic_err("failed in groupchat_onInit", FATALERR_CURSES);
+    }
 
     ChatContext *ctx = self->chatwin;
 
@@ -658,8 +678,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
     ctx->hst = calloc(1, sizeof(struct history));
     ctx->log = calloc(1, sizeof(struct chatlog));
 
-    if (ctx->log == NULL || ctx->hst == NULL)
+    if (ctx->log == NULL || ctx->hst == NULL) {
         exit_toxic_err("failed in groupchat_onInit", FATALERR_MEMORY);
+    }
 
     line_info_init(ctx->hst);
 
@@ -667,8 +688,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
         char myid[TOX_ADDRESS_SIZE];
         tox_self_get_address(m, (uint8_t *) myid);
 
-        if (log_enable(self->name, myid, NULL, ctx->log, LOG_GROUP) == -1)
+        if (log_enable(self->name, myid, NULL, ctx->log, LOG_GROUP) == -1) {
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
+        }
     }
 
     execute(ctx->history, self, m, "/log", GLOBAL_COMMAND_MODE);
@@ -698,8 +720,9 @@ ToxWindow new_group_chat(Tox *m, uint32_t groupnum)
     ChatContext *chatwin = calloc(1, sizeof(ChatContext));
     Help *help = calloc(1, sizeof(Help));
 
-    if (chatwin == NULL || help == NULL)
+    if (chatwin == NULL || help == NULL) {
         exit_toxic_err("failed in new_group_chat", FATALERR_MEMORY);
+    }
 
     ret.chatwin = chatwin;
     ret.help = help;
diff --git a/src/help.c b/src/help.c
index 141091b..c7ef7cb 100644
--- a/src/help.c
+++ b/src/help.c
@@ -40,14 +40,16 @@
 
 void help_init_menu(ToxWindow *self)
 {
-    if (self->help->win)
+    if (self->help->win) {
         delwin(self->help->win);
+    }
 
     int y2, x2;
     getmaxyx(self->window, y2, x2);
 
-    if (y2 < HELP_MENU_HEIGHT || x2 < HELP_MENU_WIDTH)
+    if (y2 < HELP_MENU_HEIGHT || x2 < HELP_MENU_WIDTH) {
         return;
+    }
 
     self->help->win = newwin(HELP_MENU_HEIGHT, HELP_MENU_WIDTH, 3, 3);
     self->help->active = true;
@@ -62,14 +64,16 @@ static void help_exit(ToxWindow *self)
 
 static void help_init_window(ToxWindow *self, int height, int width)
 {
-    if (self->help->win)
+    if (self->help->win) {
         delwin(self->help->win);
+    }
 
     int y2, x2;
     getmaxyx(stdscr, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         return;
+    }
 
     height = MIN(height, y2);
     width = MIN(width, x2);
diff --git a/src/input.c b/src/input.c
index 26c0326..abc5710 100644
--- a/src/input.c
+++ b/src/input.c
@@ -43,8 +43,9 @@ void input_new_char(ToxWindow *self, wint_t key, int x, int y, int mx_x, int mx_
     ChatContext *ctx = self->chatwin;
 
     /* this is the only place we need to do this check */
-    if (key == '\n')
+    if (key == '\n') {
         key = L'¶';
+    }
 
     int cur_len = wcwidth(key);
 
@@ -77,17 +78,19 @@ static void input_backspace(ToxWindow *self, int x, int mx_x)
     int cur_len = ctx->pos > 0 ? wcwidth(ctx->line[ctx->pos - 1]) : 0;
     int s_len = ctx->start > 0 ? wcwidth(ctx->line[ctx->start - 1]) : 0;
 
-    if (ctx->start && (x >= mx_x - cur_len))
+    if (ctx->start && (x >= mx_x - cur_len)) {
         ctx->start = MAX(0, ctx->start - 1 + (s_len - cur_len));
-    else if (ctx->start)
+    } else if (ctx->start) {
         ctx->start = MAX(0, ctx->start - cur_len);
+    }
 }
 
 /* delete a char via delete key from input field and buffer */
 static void input_delete(ToxWindow *self)
 {
-    if (del_char_buf_frnt(self->chatwin) == -1)
+    if (del_char_buf_frnt(self->chatwin) == -1) {
         sound_notify(self, notif_error, 0, NULL);
+    }
 }
 
 /* delete last typed word */
@@ -104,15 +107,17 @@ static void input_del_word(ToxWindow *self, int x, int mx_x)
 /* deletes entire line before cursor from input field and buffer */
 static void input_discard(ToxWindow *self)
 {
-    if (discard_buf(self->chatwin) == -1)
+    if (discard_buf(self->chatwin) == -1) {
         sound_notify(self, notif_error, 0, NULL);
+    }
 }
 
 /* deletes entire line after cursor from input field and buffer */
 static void input_kill(ChatContext *ctx)
 {
-    if (kill_buf(ctx) == -1)
+    if (kill_buf(ctx) == -1) {
         sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
+    }
 }
 
 static void input_yank(ToxWindow *self, int x, int mx_x)
@@ -149,8 +154,9 @@ static void input_mv_home(ToxWindow *self)
 {
     ChatContext *ctx = self->chatwin;
 
-    if (ctx->pos <= 0)
+    if (ctx->pos <= 0) {
         return;
+    }
 
     ctx->pos = 0;
     ctx->start = 0;
@@ -161,18 +167,20 @@ static void input_mv_left(ToxWindow *self, int x, int mx_x)
 {
     ChatContext *ctx = self->chatwin;
 
-    if (ctx->pos <= 0)
+    if (ctx->pos <= 0) {
         return;
+    }
 
     int cur_len = ctx->pos > 0 ? wcwidth(ctx->line[ctx->pos - 1]) : 0;
     int s_len = ctx->start > 0 ? wcwidth(ctx->line[ctx->start - 1]) : 0;
 
     --ctx->pos;
 
-    if (ctx->start && (x >= mx_x - cur_len))
+    if (ctx->start && (x >= mx_x - cur_len)) {
         ctx->start = MAX(0, ctx->start - 1 + (s_len - cur_len));
-    else if (ctx->start)
+    } else if (ctx->start) {
         ctx->start = MAX(0, ctx->start - cur_len);
+    }
 }
 
 /* moves cursor/line position right in input field and buffer */
@@ -180,8 +188,9 @@ static void input_mv_right(ToxWindow *self, int x, int mx_x)
 {
     ChatContext *ctx = self->chatwin;
 
-    if (ctx->pos >= ctx->len)
+    if (ctx->pos >= ctx->len) {
         return;
+    }
 
     ++ctx->pos;
 
diff --git a/src/line_info.c b/src/line_info.c
index 86adf58..71a15f4 100644
--- a/src/line_info.c
+++ b/src/line_info.c
@@ -40,8 +40,9 @@ void line_info_init(struct history *hst)
 {
     hst->line_root = calloc(1, sizeof(struct line_info));
 
-    if (hst->line_root == NULL)
+    if (hst->line_root == NULL) {
         exit_toxic_err("failed in line_info_init", FATALERR_MEMORY);
+    }
 
     hst->line_start = hst->line_root;
     hst->line_end = hst->line_start;
@@ -53,8 +54,9 @@ void line_info_reset_start(ToxWindow *self, struct history *hst)
 {
     struct line_info *line = hst->line_end;
 
-    if (line->prev == NULL)
+    if (line->prev == NULL) {
         return;
+    }
 
     int y2, x2;
     getmaxyx(self->window, y2, x2);
@@ -88,8 +90,9 @@ void line_info_cleanup(struct history *hst)
     int i;
 
     for (i = 0; i < hst->queue_sz; ++i) {
-        if (hst->queue[i])
+        if (hst->queue[i]) {
             free(hst->queue[i]);
+        }
     }
 
     free(hst);
@@ -114,15 +117,17 @@ static void line_info_root_fwd(struct history *hst)
 /* returns ptr to queue item 0 and removes it from queue. Returns NULL if queue is empty. */
 static struct line_info *line_info_ret_queue(struct history *hst)
 {
-    if (hst->queue_sz <= 0)
+    if (hst->queue_sz <= 0) {
         return NULL;
+    }
 
     struct line_info *line = hst->queue[0];
 
     int i;
 
-    for (i = 0; i < hst->queue_sz; ++i)
+    for (i = 0; i < hst->queue_sz; ++i) {
         hst->queue[i] = hst->queue[i + 1];
+    }
 
     --hst->queue_sz;
 
@@ -137,18 +142,21 @@ static struct line_info *line_info_ret_queue(struct history *hst)
 int line_info_add(ToxWindow *self, const char *timestr, const char *name1, const char *name2, uint8_t type,
                   uint8_t bold, uint8_t colour, const char *msg, ...)
 {
-    if (!self)
+    if (!self) {
         return -1;
+    }
 
     struct history *hst = self->chatwin->hst;
 
-    if (hst->queue_sz >= MAX_LINE_INFO_QUEUE)
+    if (hst->queue_sz >= MAX_LINE_INFO_QUEUE) {
         return -1;
+    }
 
     struct line_info *new_line = calloc(1, sizeof(struct line_info));
 
-    if (new_line == NULL)
+    if (new_line == NULL) {
         exit_toxic_err("failed in line_info_add", FATALERR_MEMORY);
+    }
 
     char frmt_msg[MAX_LINE_INFO_MSG_SIZE] = {0};
 
@@ -206,8 +214,9 @@ int line_info_add(ToxWindow *self, const char *timestr, const char *name1, const
         int i;
 
         for (i = 0; frmt_msg[i]; ++i) {
-            if (frmt_msg[i] == '\n')
+            if (frmt_msg[i] == '\n') {
                 ++new_line->newlines;
+            }
         }
     }
 
@@ -245,11 +254,13 @@ static void line_info_check_queue(ToxWindow *self)
     struct history *hst = self->chatwin->hst;
     struct line_info *line = line_info_ret_queue(hst);
 
-    if (line == NULL)
+    if (line == NULL) {
         return;
+    }
 
-    if (hst->start_id > user_settings->history_size)
+    if (hst->start_id > user_settings->history_size) {
         line_info_root_fwd(hst);
+    }
 
     line->prev = hst->line_end;
     hst->line_end->next = line;
@@ -261,8 +272,9 @@ static void line_info_check_queue(ToxWindow *self)
     getyx(self->chatwin->history, y, x);
     (void) x;
 
-    if (x2 <= SIDEBAR_WIDTH)
+    if (x2 <= SIDEBAR_WIDTH) {
         return;
+    }
 
     int offst = self->show_peerlist ? SIDEBAR_WIDTH : 0;   /* offset width of groupchat sidebar */
     int lines = 1 + line->newlines + (line->len / (x2 - offst));
@@ -284,8 +296,9 @@ void line_info_print(ToxWindow *self)
 {
     ChatContext *ctx = self->chatwin;
 
-    if (ctx == NULL)
+    if (ctx == NULL) {
         return;
+    }
 
     struct history *hst = ctx->hst;
 
@@ -293,19 +306,25 @@ void line_info_print(ToxWindow *self)
     line_info_check_queue(self);
 
     WINDOW *win = ctx->history;
+
     wclear(win);
+
     int y2, x2;
+
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= SIDEBAR_WIDTH)
+    if (x2 <= SIDEBAR_WIDTH) {
         return;
+    }
 
-    if (self->is_groupchat)
+    if (self->is_groupchat) {
         wmove(win, 0, 0);
-    else
+    } else {
         wmove(win, 2, 0);
+    }
 
     struct line_info *line = hst->line_start->next;
+
     int numlines = 0;
 
     while (line && numlines++ <= y2) {
@@ -325,10 +344,11 @@ void line_info_print(ToxWindow *self)
 
                 int nameclr = GREEN;
 
-                if (line->colour)
+                if (line->colour) {
                     nameclr = line->colour;
-                else if (type == IN_MSG)
+                } else if (type == IN_MSG) {
                     nameclr = CYAN;
+                }
 
                 wattron(win, COLOR_PAIR(nameclr));
                 wprintw(win, "%s %s: ", user_settings->line_normal, line->name1);
@@ -339,21 +359,24 @@ void line_info_print(ToxWindow *self)
                 while (msg) {
                     char *line = strsep(&msg, "\n");
 
-                    if (line[0] == '>')
+                    if (line[0] == '>') {
                         wattron(win, COLOR_PAIR(GREEN));
-                    else if (line[0] == '<')
+                    } else if (line[0] == '<') {
                         wattron(win, COLOR_PAIR(RED));
+                    }
 
                     wprintw(win, "%s%c", line, msg ? '\n' : '\0');
 
-                    if (line[0] == '>')
+                    if (line[0] == '>') {
                         wattroff(win, COLOR_PAIR(GREEN));
-                    else if (line[0] == '<')
+                    } else if (line[0] == '<') {
                         wattroff(win, COLOR_PAIR(RED));
+                    }
 
                     // change the \0 set by strsep back to \n
-                    if (msg)
+                    if (msg) {
                         msg[-1] = '\n';
+                    }
                 }
 
                 if (type == OUT_MSG && timed_out(line->timestamp, NOREAD_FLAG_TIMEOUT)) {
@@ -406,19 +429,23 @@ void line_info_print(ToxWindow *self)
                     wattroff(win, COLOR_PAIR(BLUE));
                 }
 
-                if (line->bold)
+                if (line->bold) {
                     wattron(win, A_BOLD);
+                }
 
-                if (line->colour)
+                if (line->colour) {
                     wattron(win, COLOR_PAIR(line->colour));
+                }
 
                 wprintw(win, "%s\n", line->msg);
 
-                if (line->bold)
+                if (line->bold) {
                     wattroff(win, A_BOLD);
+                }
 
-                if (line->colour)
+                if (line->colour) {
                     wattroff(win, COLOR_PAIR(line->colour));
+                }
 
                 break;
 
@@ -427,8 +454,9 @@ void line_info_print(ToxWindow *self)
                 wprintw(win, "$ ");
                 wattroff(win, COLOR_PAIR(GREEN));
 
-                if (line->msg[0])
+                if (line->msg[0]) {
                     wprintw(win, "%s", line->msg);
+                }
 
                 wprintw(win, "\n");
                 break;
@@ -492,8 +520,9 @@ void line_info_print(ToxWindow *self)
     }
 
     /* keep calling until queue is empty */
-    if (hst->queue_sz > 0)
+    if (hst->queue_sz > 0) {
         line_info_print(self);
+    }
 }
 
 /* puts msg in specified line_info msg buffer */
@@ -518,16 +547,20 @@ void line_info_set(ToxWindow *self, uint32_t id, char *msg)
 
 static void line_info_scroll_up(struct history *hst)
 {
-    if (hst->line_start->prev)
+    if (hst->line_start->prev) {
         hst->line_start = hst->line_start->prev;
-    else sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
+    } else {
+        sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
+    }
 }
 
 static void line_info_scroll_down(struct history *hst)
 {
-    if (hst->line_start->next)
+    if (hst->line_start->next) {
         hst->line_start = hst->line_start->next;
-    else sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
+    } else {
+        sound_notify(NULL, notif_error, NT_ALWAYS, NULL);
+    }
 }
 
 static void line_info_page_up(ToxWindow *self, struct history *hst)
@@ -538,8 +571,9 @@ static void line_info_page_up(ToxWindow *self, struct history *hst)
     int jump_dist = y2 / 2;
     int i;
 
-    for (i = 0; i < jump_dist && hst->line_start->prev; ++i)
+    for (i = 0; i < jump_dist && hst->line_start->prev; ++i) {
         hst->line_start = hst->line_start->prev;
+    }
 }
 
 static void line_info_page_down(ToxWindow *self, struct history *hst)
@@ -550,8 +584,9 @@ static void line_info_page_down(ToxWindow *self, struct history *hst)
     int jump_dist = y2 / 2;
     int i;
 
-    for (i = 0; i < jump_dist && hst->line_start->next; ++i)
+    for (i = 0; i < jump_dist && hst->line_start->next; ++i) {
         hst->line_start = hst->line_start->next;
+    }
 }
 
 bool line_info_onKey(ToxWindow *self, wint_t key)
diff --git a/src/log.c b/src/log.c
index 24ef560..0ccc0b9 100644
--- a/src/log.c
+++ b/src/log.c
@@ -45,8 +45,9 @@ extern struct user_settings *user_settings;
    Returns 0 on success, -1 if the path is too long */
 static int get_log_path(char *dest, int destsize, char *name, const char *selfkey, const char *otherkey, int logtype)
 {
-    if (!valid_nick(name))
+    if (!valid_nick(name)) {
         name = UNKNOWN_NAME;
+    }
 
     const char *namedash = logtype == LOG_PROMPT ? "" : "-";
     const char *set_path = user_settings->chatlogs_path;
@@ -85,10 +86,11 @@ static int get_log_path(char *dest, int destsize, char *name, const char *selfke
         return -1;
     }
 
-    if (!string_is_empty(set_path))
+    if (!string_is_empty(set_path)) {
         snprintf(dest, destsize, "%s%s-%s%s%s.log", set_path, self_id, name, namedash, other_id);
-    else
+    } else {
         snprintf(dest, destsize, "%s%s%s-%s%s%s.log", user_config_dir, LOGDIR, self_id, name, namedash, other_id);
+    }
 
     free(user_config_dir);
 
@@ -98,19 +100,22 @@ static int get_log_path(char *dest, int destsize, char *name, const char *selfke
 /* Opens log file or creates a new one */
 static int init_logging_session(char *name, const char *selfkey, const char *otherkey, struct chatlog *log, int logtype)
 {
-    if (selfkey == NULL || (logtype == LOG_CHAT && otherkey == NULL))
+    if (selfkey == NULL || (logtype == LOG_CHAT && otherkey == NULL)) {
         return -1;
+    }
 
     char log_path[MAX_STR_SIZE];
 
-    if (get_log_path(log_path, sizeof(log_path), name, selfkey, otherkey, logtype) == -1)
+    if (get_log_path(log_path, sizeof(log_path), name, selfkey, otherkey, logtype) == -1) {
         return -1;
+    }
 
     log->file = fopen(log_path, "a+");
     snprintf(log->path, sizeof(log->path), "%s", log_path);
 
-    if (log->file == NULL)
+    if (log->file == NULL) {
         return -1;
+    }
 
     return 0;
 }
@@ -119,8 +124,9 @@ static int init_logging_session(char *name, const char *selfkey, const char *oth
 
 void write_to_log(const char *msg, const char *name, struct chatlog *log, bool event)
 {
-    if (!log->log_on)
+    if (!log->log_on) {
         return;
+    }
 
     if (log->file == NULL) {
         log->log_on = false;
@@ -129,10 +135,11 @@ void write_to_log(const char *msg, const char *name, struct chatlog *log, bool e
 
     char name_frmt[TOXIC_MAX_NAME_LENGTH + 3];
 
-    if (event)
+    if (event) {
         snprintf(name_frmt, sizeof(name_frmt), "* %s", name);
-    else
+    } else {
         snprintf(name_frmt, sizeof(name_frmt), "%s:", name);
+    }
 
     const char *t = user_settings->log_timestamp_format;
     char s[MAX_STR_SIZE];
@@ -147,8 +154,9 @@ void write_to_log(const char *msg, const char *name, struct chatlog *log, bool e
 
 void log_disable(struct chatlog *log)
 {
-    if (log->file != NULL)
+    if (log->file != NULL) {
         fclose(log->file);
+    }
 
     memset(log, 0, sizeof(struct chatlog));
 }
@@ -157,8 +165,9 @@ int log_enable(char *name, const char *selfkey, const char *otherkey, struct cha
 {
     log->log_on = true;
 
-    if (log->file != NULL)
+    if (log->file != NULL) {
         return 0;
+    }
 
     if (init_logging_session(name, selfkey, otherkey, log, logtype) == -1) {
         log_disable(log);
@@ -171,18 +180,21 @@ int log_enable(char *name, const char *selfkey, const char *otherkey, struct cha
 /* Loads previous history from chat log */
 void load_chat_history(ToxWindow *self, struct chatlog *log)
 {
-    if (log->file == NULL)
+    if (log->file == NULL) {
         return;
+    }
 
     off_t sz = file_size(log->path);
 
-    if (sz <= 0)
+    if (sz <= 0) {
         return;
+    }
 
     char *hstbuf = malloc(sz + 1);
 
-    if (hstbuf == NULL)
+    if (hstbuf == NULL) {
         exit_toxic_err("failed in load_chat_history", FATALERR_MEMORY);
+    }
 
     if (fseek(log->file, 0L, SEEK_SET) == -1) {
         free(hstbuf);
@@ -204,8 +216,9 @@ void load_chat_history(ToxWindow *self, struct chatlog *log)
 
     /* start at end and backtrace L lines or to the beginning of buffer */
     for (start = sz - 1; start >= 0 && count < L; --start) {
-        if (hstbuf[start] == '\n')
+        if (hstbuf[start] == '\n') {
             ++count;
+        }
     }
 
     const char *line = strtok(&hstbuf[start + 1], "\n");
@@ -238,33 +251,40 @@ int rename_logfile(char *src, char *dest, const char *selfkey, const char *other
         log_on = log->log_on;
     }
 
-    if (log_on)
+    if (log_on) {
         log_disable(log);
+    }
 
     char newpath[MAX_STR_SIZE];
     char oldpath[MAX_STR_SIZE];
 
-    if (get_log_path(oldpath, sizeof(oldpath), src, selfkey, otherkey, LOG_CHAT) == -1)
+    if (get_log_path(oldpath, sizeof(oldpath), src, selfkey, otherkey, LOG_CHAT) == -1) {
         goto on_error;
+    }
 
-    if (!file_exists(oldpath))
+    if (!file_exists(oldpath)) {
         return 0;
+    }
 
-    if (get_log_path(newpath, sizeof(newpath), dest, selfkey, otherkey, LOG_CHAT) == -1)
+    if (get_log_path(newpath, sizeof(newpath), dest, selfkey, otherkey, LOG_CHAT) == -1) {
         goto on_error;
+    }
 
-    if (rename(oldpath, newpath) != 0)
+    if (rename(oldpath, newpath) != 0) {
         goto on_error;
+    }
 
-    if (log_on)
+    if (log_on) {
         log_enable(dest, selfkey, otherkey, log, LOG_CHAT);
+    }
 
     return 0;
 
 on_error:
 
-    if (log_on)
+    if (log_on) {
         log_enable(src, selfkey, otherkey, log, LOG_CHAT);
+    }
 
     return -1;
 }
diff --git a/src/message_queue.c b/src/message_queue.c
index 0c5667d..b988df3 100644
--- a/src/message_queue.c
+++ b/src/message_queue.c
@@ -50,8 +50,9 @@ void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type,
 
     struct cqueue_msg *new_m = malloc(sizeof(struct cqueue_msg));
 
-    if (new_m == NULL)
+    if (new_m == NULL) {
         exit_toxic_err("failed in cqueue_message", FATALERR_MEMORY);
+    }
 
     snprintf(new_m->message, sizeof(new_m->message), "%s", msg);
     new_m->len = len;
@@ -118,8 +119,9 @@ void cqueue_remove(ToxWindow *self, Tox *m, uint32_t receipt)
         struct cqueue_msg *next = msg->next;
 
         if (msg->prev == NULL) {    /* root */
-            if (next)
+            if (next) {
                 next->prev = NULL;
+            }
 
             free(msg);
             q->root = next;
diff --git a/src/misc_tools.c b/src/misc_tools.c
index 9111cd1..d659fc5 100644
--- a/src/misc_tools.c
+++ b/src/misc_tools.c
@@ -93,19 +93,21 @@ void get_time_str(char *buf, int bufsize)
 /* Converts seconds to string in format HH:mm:ss; truncates hours and minutes when necessary */
 void get_elapsed_time_str(char *buf, int bufsize, time_t secs)
 {
-    if (!secs)
+    if (!secs) {
         return;
+    }
 
     long int seconds = secs % 60;
     long int minutes = (secs % 3600) / 60;
     long int hours = secs / 3600;
 
-    if (!minutes && !hours)
+    if (!minutes && !hours) {
         snprintf(buf, bufsize, "%.2ld", seconds);
-    else if (!hours)
+    } else if (!hours) {
         snprintf(buf, bufsize, "%ld:%.2ld", minutes, seconds);
-    else
+    } else {
         snprintf(buf, bufsize, "%ld:%.2ld:%.2ld", hours, minutes, seconds);
+    }
 }
 
 /*
@@ -117,8 +119,9 @@ void get_elapsed_time_str(char *buf, int bufsize, time_t secs)
  */
 int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size_t output_size)
 {
-    if (output_size == 0 || hex_len != output_size * 2)
+    if (output_size == 0 || hex_len != output_size * 2) {
         return -1;
+    }
 
     for (size_t i = 0; i < output_size; ++i) {
         sscanf(hex_string, "%2hhx", &output[i]);
@@ -130,8 +133,9 @@ int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size
 
 int hex_string_to_bytes(char *buf, int size, const char *keystr)
 {
-    if (size % 2 != 0)
+    if (size % 2 != 0) {
         return -1;
+    }
 
     int i, res;
     const char *pos = keystr;
@@ -140,8 +144,9 @@ int hex_string_to_bytes(char *buf, int size, const char *keystr)
         res = sscanf(pos, "%2hhx", &buf[i]);
         pos += 2;
 
-        if (res == EOF || res < 1)
+        if (res == EOF || res < 1) {
             return -1;
+        }
     }
 
     return 0;
@@ -154,13 +159,15 @@ int hex_string_to_bytes(char *buf, int size, const char *keystr)
  */
 int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_t output_size)
 {
-    if (bin_id_size != TOX_ADDRESS_SIZE || output_size < (TOX_ADDRESS_SIZE * 2 + 1))
+    if (bin_id_size != TOX_ADDRESS_SIZE || output_size < (TOX_ADDRESS_SIZE * 2 + 1)) {
         return -1;
+    }
 
     size_t i;
 
-    for (i = 0; i < TOX_ADDRESS_SIZE; ++i)
+    for (i = 0; i < TOX_ADDRESS_SIZE; ++i) {
         snprintf(&output[i * 2], output_size - (i * 2), "%02X", bin_id[i] & 0xff);
+    }
 
     return 0;
 }
@@ -168,8 +175,9 @@ int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_
 /* Returns 1 if the string is empty, 0 otherwise */
 int string_is_empty(const char *string)
 {
-    if (!string)
+    if (!string) {
         return true;
+    }
 
     return string[0] == '\0';
 }
@@ -177,8 +185,9 @@ int string_is_empty(const char *string)
 /* Returns 1 if the string is empty, 0 otherwise */
 int wstring_is_empty(const wchar_t *string)
 {
-    if (!string)
+    if (!string) {
         return true;
+    }
 
     return string[0] == L'\0';
 }
@@ -188,11 +197,13 @@ int mbs_to_wcs_buf(wchar_t *buf, const char *string, size_t n)
 {
     size_t len = mbstowcs(NULL, string, 0) + 1;
 
-    if (n < len)
+    if (n < len) {
         return -1;
+    }
 
-    if ((len = mbstowcs(buf, string, n)) == (size_t) - 1)
+    if ((len = mbstowcs(buf, string, n)) == (size_t) - 1) {
         return -1;
+    }
 
     return len;
 }
@@ -202,11 +213,13 @@ int wcs_to_mbs_buf(char *buf, const wchar_t *string, size_t n)
 {
     size_t len = wcstombs(NULL, string, 0) + 1;
 
-    if (n < len)
+    if (n < len) {
         return -1;
+    }
 
-    if ((len = wcstombs(buf, string, n)) == (size_t) - 1)
+    if ((len = wcstombs(buf, string, n)) == (size_t) - 1) {
         return -1;
+    }
 
     return len;
 }
@@ -225,8 +238,9 @@ int qsort_strcasecmp_hlpr(const void *str1, const void *str2)
       - must not contain a newline or tab seqeunce */
 int valid_nick(const char *nick)
 {
-    if (!nick[0] || nick[0] == ' ')
+    if (!nick[0] || nick[0] == ' ') {
         return 0;
+    }
 
     int i;
 
@@ -238,7 +252,9 @@ int valid_nick(const char *nick)
                 || nick[i] == '\v'
                 || nick[i] == '\r')
 
+        {
             return 0;
+        }
     }
 
     return 1;
@@ -250,8 +266,9 @@ void filter_str(char *str, size_t len)
     size_t i;
 
     for (i = 0; i < len; ++i) {
-        if (str[i] == '\n' || str[i] == '\r' || str[i] == '\t' || str[i] == '\v' || str[i] == '\0')
+        if (str[i] == '\n' || str[i] == '\r' || str[i] == '\t' || str[i] == '\v' || str[i] == '\0') {
             str[i] = ' ';
+        }
     }
 }
 
@@ -263,22 +280,26 @@ size_t get_file_name(char *namebuf, size_t bufsize, const char *pathname)
     int len = strlen(pathname) - 1;
     char *path = strdup(pathname);
 
-    if (path == NULL)
+    if (path == NULL) {
         exit_toxic_err("failed in get_file_name", FATALERR_MEMORY);
+    }
 
-    while (len >= 0 && pathname[len] == '/')
+    while (len >= 0 && pathname[len] == '/') {
         path[len--] = '\0';
+    }
 
     char *finalname = strdup(path);
 
-    if (finalname == NULL)
+    if (finalname == NULL) {
         exit_toxic_err("failed in get_file_name", FATALERR_MEMORY);
+    }
 
     const char *basenm = strrchr(path, '/');
 
     if (basenm != NULL) {
-        if (basenm[1])
+        if (basenm[1]) {
             strcpy(finalname, &basenm[1]);
+        }
     }
 
     snprintf(namebuf, bufsize, "%s", finalname);
@@ -295,13 +316,15 @@ size_t get_file_name(char *namebuf, size_t bufsize, const char *pathname)
  */
 size_t get_base_dir(const char *path, size_t path_len, char *dir)
 {
-    if (path_len == 0 || path == NULL)
+    if (path_len == 0 || path == NULL) {
         return 0;
+    }
 
     size_t dir_len = char_rfind(path, '/', path_len);
 
-    if (dir_len != 0 && dir_len < path_len)
-        ++dir_len;  /* Leave trailing slash */
+    if (dir_len != 0 && dir_len < path_len) {
+        ++dir_len;    /* Leave trailing slash */
+    }
 
     memcpy(dir, path, dir_len);
     dir[dir_len] = '\0';
@@ -314,8 +337,9 @@ void str_to_lower(char *str)
 {
     int i;
 
-    for (i = 0; str[i]; ++i)
+    for (i = 0; str[i]; ++i) {
         str[i] = tolower(str[i]);
+    }
 }
 
 /* puts friendnum's nick in buf, truncating at TOXIC_MAX_NAME_LENGTH if necessary.
@@ -401,8 +425,9 @@ int char_find(int idx, const char *s, char ch)
     int i = idx;
 
     for (i = idx; s[i]; ++i) {
-        if (s[i] == ch)
+        if (s[i] == ch) {
             break;
+        }
     }
 
     return i;
@@ -419,8 +444,9 @@ int char_rfind(const char *s, char ch, int len)
     int i = 0;
 
     for (i = len; i > 0; --i) {
-        if (s[i] == ch)
+        if (s[i] == ch) {
             break;
+        }
     }
 
     return i;
@@ -460,8 +486,9 @@ off_t file_size(const char *path)
 {
     struct stat st;
 
-    if (stat(path, &st) == -1)
+    if (stat(path, &st) == -1) {
         return 0;
+    }
 
     return st.st_size;
 }
@@ -474,13 +501,15 @@ int check_file_signature(const char *signature, size_t size, FILE *fp)
 {
     char buf[size];
 
-    if (fread(buf, size, 1, fp) != 1)
+    if (fread(buf, size, 1, fp) != 1) {
         return -1;
+    }
 
     int ret = memcmp(signature, buf, size);
 
-    if (fseek(fp, 0L, SEEK_SET) == -1)
+    if (fseek(fp, 0L, SEEK_SET) == -1) {
         return -1;
+    }
 
     return ret == 0 ? 0 : 1;
 }
@@ -490,10 +519,11 @@ void set_window_title(ToxWindow *self, const char *title, int len)
 {
     char cpy[TOXIC_MAX_NAME_LENGTH + 1];
 
-    if (self->is_groupchat)   /* keep groupnumber in title */
+    if (self->is_groupchat) { /* keep groupnumber in title */
         snprintf(cpy, sizeof(cpy), "%d %s", self->num, title);
-    else
+    } else {
         snprintf(cpy, sizeof(cpy), "%s", title);
+    }
 
     if (len > MAX_WINDOW_NAME_LENGTH) {
         strcpy(&cpy[MAX_WINDOW_NAME_LENGTH - 3], "...");
diff --git a/src/name_lookup.c b/src/name_lookup.c
index 77f823d..2032367 100644
--- a/src/name_lookup.c
+++ b/src/name_lookup.c
@@ -97,42 +97,49 @@ static int load_nameserver_list(const char *path)
 {
     FILE *fp = fopen(path, "r");
 
-    if (fp == NULL)
+    if (fp == NULL) {
         return -2;
+    }
 
     char line[MAX_SERVER_LINE];
 
     while (fgets(line, sizeof(line), fp) && Nameservers.lines < MAX_SERVERS) {
         int linelen = strlen(line);
 
-        if (linelen < SERVER_KEY_SIZE * 2 + 5)
+        if (linelen < SERVER_KEY_SIZE * 2 + 5) {
             continue;
+        }
 
-        if (line[linelen - 1] == '\n')
+        if (line[linelen - 1] == '\n') {
             line[--linelen] = '\0';
+        }
 
         const char *name = strtok(line, " ");
         const char *keystr = strtok(NULL, " ");
 
-        if (name == NULL || keystr == NULL)
+        if (name == NULL || keystr == NULL) {
             continue;
+        }
 
-        if (strlen(keystr) != SERVER_KEY_SIZE * 2)
+        if (strlen(keystr) != SERVER_KEY_SIZE * 2) {
             continue;
+        }
 
         snprintf(Nameservers.names[Nameservers.lines], sizeof(Nameservers.names[Nameservers.lines]), "%s", name);
         int res = hex_string_to_bytes(Nameservers.keys[Nameservers.lines], SERVER_KEY_SIZE, keystr);
 
-        if (res == -1)
+        if (res == -1) {
             continue;
+        }
 
         ++Nameservers.lines;
     }
 
     fclose(fp);
 
-    if (Nameservers.lines < 1)
+    if (Nameservers.lines < 1) {
         return -3;
+    }
 
     return 0;
 }
@@ -145,8 +152,9 @@ static int load_nameserver_list(const char *path)
  */
 static int parse_addr(const char *addr, char *namebuf, size_t namebuf_sz, char *dombuf, size_t dombuf_sz)
 {
-    if (strlen(addr) >= (MAX_STR_SIZE - strlen(NAMESERVER_API_PATH)))
+    if (strlen(addr) >= (MAX_STR_SIZE - strlen(NAMESERVER_API_PATH))) {
         return -1;
+    }
 
     char tmpaddr[MAX_STR_SIZE];
     char *tmpname = NULL;
@@ -156,8 +164,9 @@ static int parse_addr(const char *addr, char *namebuf, size_t namebuf_sz, char *
     tmpname = strtok(tmpaddr, "@");
     tmpdom = strtok(NULL, "");
 
-    if (tmpname == NULL || tmpdom == NULL)
+    if (tmpname == NULL || tmpdom == NULL) {
         return -1;
+    }
 
     str_to_lower(tmpdom);
     snprintf(namebuf, namebuf_sz, "%s", tmpname);
@@ -197,23 +206,27 @@ static int process_response(struct Recv_Curl_Data *recv_data)
 {
     size_t prefix_size = strlen(ID_PREFIX);
 
-    if (recv_data->length < TOX_ADDRESS_SIZE * 2 + prefix_size)
+    if (recv_data->length < TOX_ADDRESS_SIZE * 2 + prefix_size) {
         return -1;
+    }
 
     const char *IDstart = strstr(recv_data->data, ID_PREFIX);
 
-    if (IDstart == NULL)
+    if (IDstart == NULL) {
         return -1;
+    }
 
-    if (strlen(IDstart) < TOX_ADDRESS_SIZE * 2 + prefix_size)
+    if (strlen(IDstart) < TOX_ADDRESS_SIZE * 2 + prefix_size) {
         return -1;
+    }
 
     char ID_string[TOX_ADDRESS_SIZE * 2 + 1];
     memcpy(ID_string, IDstart + prefix_size, TOX_ADDRESS_SIZE * 2);
     ID_string[TOX_ADDRESS_SIZE * 2] = 0;
 
-    if (hex_string_to_bin(ID_string, strlen(ID_string), t_data.id_bin, sizeof(t_data.id_bin)) == -1)
+    if (hex_string_to_bin(ID_string, strlen(ID_string), t_data.id_bin, sizeof(t_data.id_bin)) == -1) {
         return -1;
+    }
 
     return 0;
 }
@@ -234,10 +247,11 @@ void *lookup_thread_func(void *data)
     char real_domain[MAX_DOMAIN_SIZE];
 
     if (!get_domain_match(nameserver_key, real_domain, sizeof(real_domain), input_domain)) {
-        if (!strcasecmp(input_domain, "utox.org"))
+        if (!strcasecmp(input_domain, "utox.org")) {
             lookup_error(self, "utox.org uses deprecated DNS-based lookups and is no longer supported by Toxic.");
-        else
+        } else {
             lookup_error(self, "Name server domain not found.");
+        }
 
         kill_lookup_thread();
     }
diff --git a/src/notify.c b/src/notify.c
index eaed79e..ae73ba0 100644
--- a/src/notify.c
+++ b/src/notify.c
@@ -104,21 +104,24 @@ struct _ActiveNotifications {
 /* coloured tab notifications: primary notification type */
 static void tab_notify(ToxWindow *self, uint64_t flags)
 {
-    if (self == NULL)
+    if (self == NULL) {
         return;
+    }
 
-    if (flags & NT_WNDALERT_0)
+    if (flags & NT_WNDALERT_0) {
         self->alert = WINDOW_ALERT_0;
-    else if ( (flags & NT_WNDALERT_1) && (!self->alert || self->alert > WINDOW_ALERT_0) )
+    } else if ((flags & NT_WNDALERT_1) && (!self->alert || self->alert > WINDOW_ALERT_0)) {
         self->alert = WINDOW_ALERT_1;
-    else if ( (flags & NT_WNDALERT_2) && (!self->alert || self->alert > WINDOW_ALERT_1) )
+    } else if ((flags & NT_WNDALERT_2) && (!self->alert || self->alert > WINDOW_ALERT_1)) {
         self->alert = WINDOW_ALERT_2;
+    }
 }
 
 static bool notifications_are_disabled(uint64_t flags)
 {
-    if (user_settings->alerts != ALERTS_ENABLED)
+    if (user_settings->alerts != ALERTS_ENABLED) {
         return true;
+    }
 
     bool res = (flags & NT_RESTOL) && (Control.cooldown > get_unix_time());
 #ifdef X11
@@ -161,7 +164,9 @@ void m_open_device()
 {
     last_opened_update = get_unix_time();
 
-    if (device_opened) return;
+    if (device_opened) {
+        return;
+    }
 
     /* Blah error check */
     open_primary_device(output, &Control.device_idx, 48000, 20, 1);
@@ -171,7 +176,9 @@ void m_open_device()
 
 void m_close_device()
 {
-    if (!device_opened) return;
+    if (!device_opened) {
+        return;
+    }
 
     close_device(output, Control.device_idx);
 
@@ -198,15 +205,18 @@ void graceful_clear()
 
 #endif
 
-                if (actives[i].id_indicator)
+                if (actives[i].id_indicator) {
                     *actives[i].id_indicator = -1;    /* reset indicator value */
+                }
 
-                if ( actives[i].looping ) {
+                if (actives[i].looping) {
                     stop_sound(i);
                 } else {
-                    if (!is_playing(actives[i].source))
+                    if (!is_playing(actives[i].source)) {
                         memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
-                    else break;
+                    } else {
+                        break;
+                    }
                 }
             }
         }
@@ -241,7 +251,9 @@ void *do_playing(void *_p)
 
         for (i = 0; i < ACTIVE_NOTIFS_MAX; i ++) {
 
-            if (actives[i].looping) has_looping = true;
+            if (actives[i].looping) {
+                has_looping = true;
+            }
 
             test_active_notify = actives[i].active && !actives[i].looping;
 #ifdef BOX_NOTIFY
@@ -249,8 +261,9 @@ void *do_playing(void *_p)
 #endif
 
             if (test_active_notify) {
-                if (actives[i].id_indicator)
+                if (actives[i].id_indicator) {
                     *actives[i].id_indicator = -1;    /* reset indicator value */
+                }
 
                 if (!is_playing(actives[i].source)) {
                     /* Close */
@@ -267,8 +280,9 @@ void *do_playing(void *_p)
                 notify_notification_close(actives[i].box, &ignore);
                 actives[i].box = NULL;
 
-                if (actives[i].id_indicator)
+                if (actives[i].id_indicator) {
                     *actives[i].id_indicator = -1;    /* reset indicator value */
+                }
 
                 if (!actives[i].looping && !is_playing(actives[i].source)) {
                     /* stop source if not looping or playing, just terminate box */
@@ -303,7 +317,7 @@ int play_source(uint32_t source, uint32_t buffer, bool looping)
 
     for (; i < ACTIVE_NOTIFS_MAX && actives[i].active; i ++);
 
-    if ( i == ACTIVE_NOTIFS_MAX ) {
+    if (i == ACTIVE_NOTIFS_MAX) {
         return -1; /* Full */
     }
 
@@ -338,8 +352,9 @@ void *do_playing(void *_p)
                 notify_notification_close(actives[i].box, &ignore);
                 actives[i].box = NULL;
 
-                if (actives[i].id_indicator)
+                if (actives[i].id_indicator) {
                     *actives[i].id_indicator = -1;    /* reset indicator value */
+                }
 
                 memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
             }
@@ -364,8 +379,9 @@ void graceful_clear()
             actives[i].box = NULL;
         }
 
-        if (actives[i].id_indicator)
+        if (actives[i].id_indicator) {
             *actives[i].id_indicator = -1;    /* reset indicator value */
+        }
 
         memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
     }
@@ -391,13 +407,14 @@ int init_notify(int login_cooldown, int notification_timeout)
 
 #if defined(SOUND_NOTIFY) || defined(BOX_NOTIFY)
 
-    if (pthread_mutex_init(Control.poll_mutex, NULL) != 0)
+    if (pthread_mutex_init(Control.poll_mutex, NULL) != 0) {
         return -1;
+    }
 
     Control.poll_active = 1;
     pthread_t thread;
 
-    if (pthread_create(&thread, NULL, do_playing, NULL) != 0 || pthread_detach(thread) != 0 ) {
+    if (pthread_create(&thread, NULL, do_playing, NULL) != 0 || pthread_detach(thread) != 0) {
         pthread_mutex_destroy(Control.poll_mutex);
         Control.poll_active = 0;
         return -1;
@@ -419,7 +436,7 @@ void terminate_notify()
 #if defined(SOUND_NOTIFY) || defined(BOX_NOTIFY)
     control_lock();
 
-    if ( !Control.poll_active ) {
+    if (!Control.poll_active) {
         control_unlock();
         return;
     }
@@ -433,7 +450,9 @@ void terminate_notify()
 #ifdef SOUND_NOTIFY
     int i = 0;
 
-    for (; i < SOUNDS_SIZE; i ++) free(Control.sounds[i]);
+    for (; i < SOUNDS_SIZE; i ++) {
+        free(Control.sounds[i]);
+    }
 
     alutExit();
 #endif /* SOUND_NOTIFY */
@@ -446,7 +465,9 @@ void terminate_notify()
 #ifdef SOUND_NOTIFY
 int set_sound(Notification sound, const char *value)
 {
-    if (sound == silent) return 0;
+    if (sound == silent) {
+        return 0;
+    }
 
     free(Control.sounds[sound]);
 
@@ -487,11 +508,14 @@ int play_notify_sound(Notification notif, uint64_t flags)
 {
     int rc = -1;
 
-    if (flags & NT_BEEP) beep();
+    if (flags & NT_BEEP) {
+        beep();
+    }
 
     if (notif != silent) {
-        if ( !Control.poll_active || !Control.sounds[notif] )
+        if (!Control.poll_active || !Control.sounds[notif]) {
             return -1;
+        }
 
         rc = play_sound_internal(notif, flags & NT_LOOP ? 1 : 0);
     }
@@ -502,7 +526,7 @@ int play_notify_sound(Notification notif, uint64_t flags)
 
 void stop_sound(int id)
 {
-    if (id >= 0 && id < ACTIVE_NOTIFS_MAX && actives[id].looping && actives[id].active ) {
+    if (id >= 0 && id < ACTIVE_NOTIFS_MAX && actives[id].looping && actives[id].active) {
 #ifdef BOX_NOTIFY
 
         if (actives[id].box) {
@@ -512,8 +536,9 @@ void stop_sound(int id)
 
 #endif
 
-        if (actives[id].id_indicator)
+        if (actives[id].id_indicator) {
             *actives[id].id_indicator = -1;
+        }
 
 //         alSourcei(actives[id].source, AL_LOOPING, false);
         alSourceStop(actives[id].source);
@@ -530,8 +555,9 @@ static int m_play_sound(Notification notif, uint64_t flags)
     return play_notify_sound(notif, flags);
 #else
 
-    if (notif != silent)
+    if (notif != silent) {
         beep();
+    }
 
     return -1;
 #endif /* SOUND_NOTIFY */
@@ -547,23 +573,25 @@ int sound_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_in
 {
     tab_notify(self, flags);
 
-    if (notifications_are_disabled(flags))
+    if (notifications_are_disabled(flags)) {
         return -1;
+    }
 
     int id = -1;
     control_lock();
 
-    if (self && (!self->stb || self->stb->status != TOX_USER_STATUS_BUSY))
+    if (self && (!self->stb || self->stb->status != TOX_USER_STATUS_BUSY)) {
         id = m_play_sound(notif, flags);
-    else if (flags & NT_ALWAYS)
+    } else if (flags & NT_ALWAYS) {
         id = m_play_sound(notif, flags);
+    }
 
 #if defined(BOX_NOTIFY) && !defined(SOUND_NOTIFY)
 
     if (id == -1) {
         for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].box; id++);
 
-        if ( id == ACTIVE_NOTIFS_MAX ) {
+        if (id == ACTIVE_NOTIFS_MAX) {
             control_unlock();
             return -1; /* Full */
         }
@@ -571,7 +599,7 @@ int sound_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_in
 
 #endif
 
-    if ( id_indicator && id != -1 ) {
+    if (id_indicator && id != -1) {
         actives[id].id_indicator = id_indicator;
         *id_indicator = id;
     }
@@ -585,10 +613,13 @@ int sound_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id)
 {
     tab_notify(self, flags);
 
-    if (notifications_are_disabled(flags))
+    if (notifications_are_disabled(flags)) {
         return -1;
+    }
 
-    if (id < 0 || id >= ACTIVE_NOTIFS_MAX) return -1;
+    if (id < 0 || id >= ACTIVE_NOTIFS_MAX) {
+        return -1;
+    }
 
 #ifdef SOUND_NOTIFY
     control_lock();
@@ -617,8 +648,9 @@ int sound_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id)
     return id;
 #else
 
-    if (notif != silent)
+    if (notif != silent) {
         beep();
+    }
 
     return 0;
 #endif /* SOUND_NOTIFY */
@@ -644,7 +676,7 @@ int box_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indi
 
         for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].active; id ++);
 
-        if ( id == ACTIVE_NOTIFS_MAX ) {
+        if (id == ACTIVE_NOTIFS_MAX) {
             control_unlock();
             return -1; /* Full */
         }
@@ -652,27 +684,33 @@ int box_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indi
         actives[id].active = 1;
         actives[id].id_indicator = id_indicator;
 
-        if (id_indicator) *id_indicator = id;
+        if (id_indicator) {
+            *id_indicator = id;
+        }
     }
 
 #else
 
-    if (id == -1)
+    if (id == -1) {
         return -1;
+    }
 
 #endif    /* SOUND_NOTIFY */
 
     snprintf(actives[id].title, sizeof(actives[id].title), "%s", title);
 
-    if (strlen(title) > 23) strcpy(actives[id].title + 20, "...");
+    if (strlen(title) > 23) {
+        strcpy(actives[id].title + 20, "...");
+    }
 
     va_list __ARGS__;
-    va_start (__ARGS__, format);
-    vsnprintf (actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
-    va_end (__ARGS__);
+    va_start(__ARGS__, format);
+    vsnprintf(actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
+    va_end(__ARGS__);
 
-    if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3)
+    if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3) {
         strcpy(actives[id].messages[0] + MAX_BOX_MSG_LEN - 3, "...");
+    }
 
     actives[id].box = notify_notification_new(actives[id].title, actives[id].messages[0], NULL);
     actives[id].size++;
@@ -699,8 +737,9 @@ int box_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id, con
 
 #ifdef BOX_NOTIFY
 
-    if (sound_notify2(self, notif, flags, id) == -1)
+    if (sound_notify2(self, notif, flags, id) == -1) {
         return -1;
+    }
 
     control_lock();
 
@@ -710,12 +749,13 @@ int box_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id, con
     }
 
     va_list __ARGS__;
-    va_start (__ARGS__, format);
-    vsnprintf (actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
-    va_end (__ARGS__);
+    va_start(__ARGS__, format);
+    vsnprintf(actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
+    va_end(__ARGS__);
 
-    if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3)
+    if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3) {
         strcpy(actives[id].messages[actives[id].size] + MAX_BOX_MSG_LEN - 3, "...");
+    }
 
     actives[id].size++;
     actives[id].n_timeout = get_unix_time() + Control.notif_timeout / 1000;
@@ -746,8 +786,9 @@ int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const
 {
     tab_notify(self, flags);
 
-    if (notifications_are_disabled(flags))
+    if (notifications_are_disabled(flags)) {
         return -1;
+    }
 
 #ifdef BOX_NOTIFY
 
@@ -757,7 +798,7 @@ int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const
 
     for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].active; id ++);
 
-    if ( id == ACTIVE_NOTIFS_MAX ) {
+    if (id == ACTIVE_NOTIFS_MAX) {
         control_unlock();
         return -1; /* Full */
     }
@@ -769,15 +810,18 @@ int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const
 
     snprintf(actives[id].title, sizeof(actives[id].title), "%s", title);
 
-    if (strlen(title) > 23) strcpy(actives[id].title + 20, "...");
+    if (strlen(title) > 23) {
+        strcpy(actives[id].title + 20, "...");
+    }
 
     va_list __ARGS__;
-    va_start (__ARGS__, format);
-    vsnprintf (actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
-    va_end (__ARGS__);
+    va_start(__ARGS__, format);
+    vsnprintf(actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
+    va_end(__ARGS__);
 
-    if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3)
+    if (strlen(actives[id].messages[0]) > MAX_BOX_MSG_LEN - 3) {
         strcpy(actives[id].messages[0] + MAX_BOX_MSG_LEN - 3, "...");
+    }
 
     actives[id].active = 1;
     actives[id].box = notify_notification_new(actives[id].title, actives[id].messages[0], NULL);
@@ -800,25 +844,27 @@ int box_silent_notify2(ToxWindow *self, uint64_t flags, int id, const char *form
 {
     tab_notify(self, flags);
 
-    if (notifications_are_disabled(flags))
+    if (notifications_are_disabled(flags)) {
         return -1;
+    }
 
 #ifdef BOX_NOTIFY
     control_lock();
 
-    if (id < 0 || id >= ACTIVE_NOTIFS_MAX || !actives[id].box || actives[id].size >= MAX_BOX_MSG_LEN + 1 ) {
+    if (id < 0 || id >= ACTIVE_NOTIFS_MAX || !actives[id].box || actives[id].size >= MAX_BOX_MSG_LEN + 1) {
         control_unlock();
         return -1;
     }
 
 
     va_list __ARGS__;
-    va_start (__ARGS__, format);
-    vsnprintf (actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
-    va_end (__ARGS__);
+    va_start(__ARGS__, format);
+    vsnprintf(actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
+    va_end(__ARGS__);
 
-    if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3)
+    if (strlen(actives[id].messages[actives[id].size]) > MAX_BOX_MSG_LEN - 3) {
         strcpy(actives[id].messages[actives[id].size] + MAX_BOX_MSG_LEN - 3, "...");
+    }
 
     actives[id].size ++;
     actives[id].n_timeout = get_unix_time() + Control.notif_timeout / 1000;
diff --git a/src/prompt.c b/src/prompt.c
index e062006..a9bde45 100644
--- a/src/prompt.c
+++ b/src/prompt.c
@@ -162,8 +162,9 @@ void prompt_update_statusmessage(ToxWindow *prompt, Tox *m, const char *statusms
     TOX_ERR_SET_INFO err;
     tox_self_set_status_message(m, (uint8_t *) statusmsg, len, &err);
 
-    if (err != TOX_ERR_SET_INFO_OK)
+    if (err != TOX_ERR_SET_INFO_OK) {
         line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set note (error %d)\n", err);
+    }
 }
 
 /* Updates own status in prompt statusbar */
@@ -184,8 +185,9 @@ TOX_CONNECTION prompt_selfConnectionStatus(void)
    Returns request number on success, -1 if queue is full. */
 static int add_friend_request(const char *public_key, const char *data)
 {
-    if (FrndRequests.max_idx >= MAX_FRIEND_REQUESTS)
+    if (FrndRequests.max_idx >= MAX_FRIEND_REQUESTS) {
         return -1;
+    }
 
     int i;
 
@@ -195,8 +197,9 @@ static int add_friend_request(const char *public_key, const char *data)
             memcpy(FrndRequests.request[i].key, public_key, TOX_PUBLIC_KEY_SIZE);
             snprintf(FrndRequests.request[i].msg, sizeof(FrndRequests.request[i].msg), "%s", data);
 
-            if (i == FrndRequests.max_idx)
+            if (i == FrndRequests.max_idx) {
                 ++FrndRequests.max_idx;
+            }
 
             ++FrndRequests.num_requests;
 
@@ -215,11 +218,13 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     getyx(self->window, y, x);
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= 0 || y2 <= 0)
+    if (x2 <= 0 || y2 <= 0) {
         return;
+    }
 
-    if (ctx->pastemode && key == '\r')
+    if (ctx->pastemode && key == '\r') {
         key = '\n';
+    }
 
     /* ignore non-menu related input if active */
     if (self->help->active) {
@@ -232,8 +237,9 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
         return;
     }
 
-    if (line_info_onKey(self, key))
+    if (line_info_onKey(self, key)) {
         return;
+    }
 
     input_handle(self, key, x, y, x2, y2);
 
@@ -241,12 +247,14 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
         if (ctx->len > 1 && ctx->line[0] == '/') {
             int diff = -1;
 
-            if (wcsncmp(ctx->line, L"/avatar \"", wcslen(L"/avatar \"")) == 0)
+            if (wcsncmp(ctx->line, L"/avatar \"", wcslen(L"/avatar \"")) == 0) {
                 diff = dir_match(self, m, ctx->line, L"/avatar");
+            }
 
 #ifdef PYTHON
-            else if (wcsncmp(ctx->line, L"/run \"", wcslen(L"/run \"")) == 0)
+            else if (wcsncmp(ctx->line, L"/run \"", wcslen(L"/run \"")) == 0) {
                 diff = dir_match(self, m, ctx->line, L"/run");
+            }
 
 #endif
 
@@ -257,8 +265,9 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
                     {"busy"},
                 };
                 diff = complete_line(self, status_cmd_list, 3, 8);
-            } else
+            } else {
                 diff = complete_line(self, glob_cmd_list, AC_NUM_GLOB_COMMANDS, MAX_CMDNAME_SIZE);
+            }
 
             if (diff != -1) {
                 if (x + diff > x2 - 1) {
@@ -280,8 +289,9 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 
             char line[MAX_STR_SIZE] = {0};
 
-            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
+            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1) {
                 memset(&line, 0, sizeof(line));
+            }
 
             line_info_add(self, NULL, NULL, NULL, PROMPT, 0, 0, "%s", line);
             execute(ctx->history, self, m, line, GLOBAL_COMMAND_MODE);
@@ -298,8 +308,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         return;
+    }
 
     ChatContext *ctx = self->chatwin;
 
@@ -311,8 +322,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
 
     curs_set(1);
 
-    if (ctx->len > 0)
+    if (ctx->len > 0) {
         mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
+    }
 
     StatusBar *statusbar = self->stb;
 
@@ -372,7 +384,7 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
 
         pthread_mutex_lock(&Winthread.lock);
         size_t slen = tox_self_get_status_message_size(m);
-        tox_self_get_status_message (m, (uint8_t *) statusmsg);
+        tox_self_get_status_message(m, (uint8_t *) statusmsg);
         statusmsg[slen] = '\0';
         snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
         statusbar->statusmsg_len = strlen(statusbar->statusmsg);
@@ -392,8 +404,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
         statusbar->statusmsg_len = maxlen;
     }
 
-    if (statusbar->statusmsg[0])
+    if (statusbar->statusmsg[0]) {
         wprintw(statusbar->topline, " : %s", statusbar->statusmsg);
+    }
 
     pthread_mutex_unlock(&Winthread.lock);
 
@@ -408,8 +421,9 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
 
     wnoutrefresh(self->window);
 
-    if (self->help->active)
+    if (self->help->active) {
         help_onDraw(self);
+    }
 }
 
 static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnum, TOX_CONNECTION connection_status)
@@ -419,8 +433,9 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
     char nick[TOX_MAX_NAME_LENGTH] = {0};    /* stop removing this initiation */
     get_nick_truncate(m, nick, friendnum);
 
-    if (!nick[0])
+    if (!nick[0]) {
         snprintf(nick, sizeof(nick), "%s", UNKNOWN_NAME);
+    }
 
     char timefrmt[TIME_STR_SIZE];
     get_time_str(timefrmt, sizeof(timefrmt));
@@ -437,10 +452,10 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
 
         if (self->active_box != -1)
             box_notify2(self, user_log_in, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, self->active_box,
-                        "%s has come online", nick );
+                        "%s has come online", nick);
         else
             box_notify(self, user_log_in, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, &self->active_box,
-                       "Toxic", "%s has come online", nick );
+                       "Toxic", "%s has come online", nick);
     } else if (connection_status == TOX_CONNECTION_NONE) {
         msg = "has gone offline";
         line_info_add(self, timefrmt, nick, NULL, DISCONNECTION, 0, RED, msg);
@@ -448,10 +463,10 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
 
         if (self->active_box != -1)
             box_notify2(self, user_log_out, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, self->active_box,
-                        "%s has gone offline", nick );
+                        "%s has gone offline", nick);
         else
             box_notify(self, user_log_out, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, &self->active_box,
-                       "Toxic", "%s has gone offline", nick );
+                       "Toxic", "%s has gone offline", nick);
     }
 }
 
@@ -482,8 +497,9 @@ void prompt_init_statusbar(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         exit_toxic_err("failed in prompt_init_statusbar", FATALERR_CURSES);
+    }
 
     (void) y2;
 
@@ -542,8 +558,9 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
     int y2, x2;
     getmaxyx(self->window, y2, x2);
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         exit_toxic_err("failed in prompt_onInit", FATALERR_CURSES);
+    }
 
     ChatContext *ctx = self->chatwin;
     ctx->history = subwin(self->window, y2 - CHATBOX_HEIGHT + 1, x2, 0, 0);
@@ -552,8 +569,9 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
     ctx->log = calloc(1, sizeof(struct chatlog));
     ctx->hst = calloc(1, sizeof(struct history));
 
-    if (ctx->log == NULL || ctx->hst == NULL)
+    if (ctx->log == NULL || ctx->hst == NULL) {
         exit_toxic_err("failed in prompt_onInit", FATALERR_MEMORY);
+    }
 
     line_info_init(ctx->hst);
 
@@ -561,15 +579,17 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
         char myid[TOX_ADDRESS_SIZE];
         tox_self_get_address(m, (uint8_t *) myid);
 
-        if (log_enable(self->name, myid, NULL, ctx->log, LOG_PROMPT) == -1)
+        if (log_enable(self->name, myid, NULL, ctx->log, LOG_PROMPT) == -1) {
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
+        }
     }
 
     scrollok(ctx->history, 0);
     wmove(self->window, y2 - CURS_Y_OFFSET, 0);
 
-    if (user_settings->show_welcome_msg == SHOW_WELCOME_MSG_ON)
+    if (user_settings->show_welcome_msg == SHOW_WELCOME_MSG_ON) {
         print_welcome_msg(self);
+    }
 }
 
 ToxWindow new_prompt(void)
@@ -593,8 +613,9 @@ ToxWindow new_prompt(void)
     StatusBar *stb = calloc(1, sizeof(StatusBar));
     Help *help = calloc(1, sizeof(Help));
 
-    if (stb == NULL || chatwin == NULL || help == NULL)
+    if (stb == NULL || chatwin == NULL || help == NULL) {
         exit_toxic_err("failed in new_prompt", FATALERR_MEMORY);
+    }
 
     ret.chatwin = chatwin;
     ret.stb = stb;
diff --git a/src/python_api.c b/src/python_api.c
index 93d106f..8220f5f 100644
--- a/src/python_api.c
+++ b/src/python_api.c
@@ -39,8 +39,9 @@ static PyObject *python_api_display(PyObject *self, PyObject *args)
 {
     const char *msg;
 
-    if (!PyArg_ParseTuple(args, "s", &msg))
+    if (!PyArg_ParseTuple(args, "s", &msg)) {
         return NULL;
+    }
 
     api_display(msg);
     return Py_None;
@@ -51,13 +52,15 @@ static PyObject *python_api_get_nick(PyObject *self, PyObject *args)
     char     *name;
     PyObject *ret;
 
-    if (!PyArg_ParseTuple(args, ""))
+    if (!PyArg_ParseTuple(args, "")) {
         return NULL;
+    }
 
     name = api_get_nick();
 
-    if (name == NULL)
+    if (name == NULL) {
         return NULL;
+    }
 
     ret  = Py_BuildValue("s", name);
     free(name);
@@ -68,8 +71,9 @@ static PyObject *python_api_get_status(PyObject *self, PyObject *args)
 {
     PyObject        *ret = NULL;
 
-    if (!PyArg_ParseTuple(args, ""))
+    if (!PyArg_ParseTuple(args, "")) {
         return NULL;
+    }
 
     switch (api_get_status()) {
         case TOX_USER_STATUS_NONE:
@@ -93,13 +97,15 @@ static PyObject *python_api_get_status_message(PyObject *self, PyObject *args)
     char     *status;
     PyObject *ret;
 
-    if (!PyArg_ParseTuple(args, ""))
+    if (!PyArg_ParseTuple(args, "")) {
         return NULL;
+    }
 
     status = api_get_status_message();
 
-    if (status == NULL)
+    if (status == NULL) {
         return NULL;
+    }
 
     ret    = Py_BuildValue("s", status);
     free(status);
@@ -113,15 +119,17 @@ static PyObject *python_api_get_all_friends(PyObject *self, PyObject *args)
     PyObject    *cur, *ret;
     char         pubkey_buf[TOX_PUBLIC_KEY_SIZE * 2 + 1];
 
-    if (!PyArg_ParseTuple(args, ""))
+    if (!PyArg_ParseTuple(args, "")) {
         return NULL;
+    }
 
     friends = api_get_friendslist();
     ret     = PyList_New(0);
 
     for (i = 0; i < friends.num_friends; i++) {
-        for (ii = 0; ii < TOX_PUBLIC_KEY_SIZE; ii++)
+        for (ii = 0; ii < TOX_PUBLIC_KEY_SIZE; ii++) {
             snprintf(pubkey_buf + ii * 2, 3, "%02X", friends.list[i].pub_key[ii] & 0xff);
+        }
 
         pubkey_buf[TOX_PUBLIC_KEY_SIZE * 2] = '\0';
         cur = Py_BuildValue("(s,s)", friends.list[i].name, pubkey_buf);
@@ -135,8 +143,9 @@ static PyObject *python_api_send(PyObject *self, PyObject *args)
 {
     const char *msg;
 
-    if (!PyArg_ParseTuple(args, "s", &msg))
+    if (!PyArg_ParseTuple(args, "s", &msg)) {
         return NULL;
+    }
 
     api_send(msg);
     return Py_None;
@@ -147,8 +156,9 @@ static PyObject *python_api_execute(PyObject *self, PyObject *args)
     int         mode;
     const char *command;
 
-    if (!PyArg_ParseTuple(args, "si", &command, &mode))
+    if (!PyArg_ParseTuple(args, "si", &command, &mode)) {
         return NULL;
+    }
 
     api_execute(command, mode);
     return Py_None;
@@ -161,8 +171,9 @@ static PyObject *python_api_register(PyObject *self, PyObject *args)
     const char *command, *help;
     PyObject   *callback;
 
-    if (!PyArg_ParseTuple(args, "ssO:register_command", &command, &help, &callback))
+    if (!PyArg_ParseTuple(args, "ssO:register_command", &command, &help, &callback)) {
         return NULL;
+    }
 
     if (!PyCallable_Check(callback)) {
         PyErr_SetString(PyExc_TypeError, "Calback parameter must be callable");
@@ -186,21 +197,24 @@ static PyObject *python_api_register(PyObject *self, PyObject *args)
             Py_XINCREF(callback);
             cur->next = malloc(sizeof(struct python_registered_func));
 
-            if (cur->next == NULL)
+            if (cur->next == NULL) {
                 return PyErr_NoMemory();
+            }
 
             command_len     = strlen(command);
             cur->next->name = malloc(command_len + 1);
 
-            if (cur->next->name == NULL)
+            if (cur->next->name == NULL) {
                 return PyErr_NoMemory();
+            }
 
             strncpy(cur->next->name, command, command_len + 1);
             help_len        = strlen(help);
             cur->next->help = malloc(help_len + 1);
 
-            if (cur->next->help == NULL)
+            if (cur->next->help == NULL) {
                 return PyErr_NoMemory();
+            }
 
             strncpy(cur->next->help, help, help_len + 1);
             cur->next->callback = callback;
@@ -252,8 +266,9 @@ void terminate_python(void)
 {
     struct python_registered_func *cur, *old;
 
-    if (python_commands.name != NULL)
+    if (python_commands.name != NULL) {
         free(python_commands.name);
+    }
 
     for (cur = python_commands.next; cur != NULL;) {
         old = cur;
@@ -284,19 +299,22 @@ int do_python_command(int num_args, char (*args)[MAX_STR_SIZE])
     struct python_registered_func *cur;
 
     for (cur = &python_commands; cur != NULL; cur = cur->next) {
-        if (cur->name == NULL)
+        if (cur->name == NULL) {
             continue;
+        }
 
         if (!strcmp(args[0], cur->name)) {
             args_strings = PyList_New(0);
 
-            for (i = 1; i < num_args; i++)
+            for (i = 1; i < num_args; i++) {
                 PyList_Append(args_strings, Py_BuildValue("s", args[i]));
+            }
 
             callback_args = PyTuple_Pack(1, args_strings);
 
-            if (PyObject_CallObject(cur->callback, callback_args) == NULL)
+            if (PyObject_CallObject(cur->callback, callback_args) == NULL) {
                 api_display("Exception raised in callback function");
+            }
 
             return 0;
         }
@@ -311,8 +329,9 @@ int python_num_registered_handlers(void)
     struct python_registered_func *cur;
 
     for (cur = &python_commands; cur != NULL; cur = cur->next) {
-        if (cur->name != NULL)
+        if (cur->name != NULL) {
             n++;
+        }
     }
 
     return n;
@@ -340,8 +359,9 @@ void python_draw_handler_help(WINDOW *win)
     struct python_registered_func *cur;
 
     for (cur = &python_commands; cur != NULL; cur = cur->next) {
-        if (cur->name != NULL)
+        if (cur->name != NULL) {
             wprintw(win, "  %-29s: %.50s\n", cur->name, cur->help);
+        }
     }
 }
 #endif /* PYTHON */
diff --git a/src/qr_code.c b/src/qr_code.c
index 104a3f7..102ece9 100644
--- a/src/qr_code.c
+++ b/src/qr_code.c
@@ -52,8 +52,9 @@ int ID_to_QRcode_txt(const char *tox_id, const char *outfile)
 {
     FILE *fp = fopen(outfile, "wb");
 
-    if (fp == NULL)
+    if (fp == NULL) {
         return -1;
+    }
 
     QRcode *qr_obj = QRcode_encodeString(tox_id, 0, QR_ECLEVEL_L, QR_MODE_8, 0);
 
@@ -65,14 +66,16 @@ int ID_to_QRcode_txt(const char *tox_id, const char *outfile)
     size_t width = qr_obj->width;
     size_t i, j;
 
-    for (i = 0; i < width + BORDER_LEN * 2; ++i)
+    for (i = 0; i < width + BORDER_LEN * 2; ++i) {
         fprintf(fp, "%s", CHAR_1);
+    }
 
     fprintf(fp, "\n");
 
     for (i = 0; i < width; i += 2) {
-        for (j = 0; j < BORDER_LEN; ++j)
+        for (j = 0; j < BORDER_LEN; ++j) {
             fprintf(fp, "%s", CHAR_1);
+        }
 
         const unsigned char *row_1 = qr_obj->data + width * i;
         const unsigned char *row_2 = row_1 + width;
@@ -81,18 +84,20 @@ int ID_to_QRcode_txt(const char *tox_id, const char *outfile)
             bool x = row_1[j] & 1;
             bool y = (i + 1) < width ? (row_2[j] & 1) : false;
 
-            if (x && y)
+            if (x && y) {
                 fprintf(fp, " ");
-            else if (x)
+            } else if (x) {
                 fprintf(fp, "%s", CHAR_2);
-            else if (y)
+            } else if (y) {
                 fprintf(fp, "%s", CHAR_3);
-            else
+            } else {
                 fprintf(fp, "%s", CHAR_1);
+            }
         }
 
-        for (j = 0; j < BORDER_LEN; ++j)
+        for (j = 0; j < BORDER_LEN; ++j) {
             fprintf(fp, "%s", CHAR_1);
+        }
 
         fprintf(fp, "\n");
     }
diff --git a/src/settings.c b/src/settings.c
index 4fe1303..b2e7336 100644
--- a/src/settings.c
+++ b/src/settings.c
@@ -124,10 +124,10 @@ static void ui_defaults(struct user_settings *settings)
     snprintf(settings->line_normal, LINE_HINT_MAX + 1, "%s", LINE_NORMAL);
 
     settings->mplex_away = MPLEX_ON;
-    snprintf (settings->mplex_away_note,
-              sizeof (settings->mplex_away_note),
-              "%s",
-              MPLEX_AWAY_NOTE);
+    snprintf(settings->mplex_away_note,
+             sizeof(settings->mplex_away_note),
+             "%s",
+             MPLEX_AWAY_NOTE);
 }
 
 static const struct keys_strings {
@@ -253,15 +253,18 @@ static int key_parse(const char **bind)
     int len = strlen(*bind);
 
     if (len > 5) {
-        if (strncasecmp(*bind, "ctrl+", 5) == 0 && toupper(bind[0][5]) != 'M')  /* ctrl+m cannot be used */
+        if (strncasecmp(*bind, "ctrl+", 5) == 0 && toupper(bind[0][5]) != 'M') { /* ctrl+m cannot be used */
             return toupper(bind[0][5]) - 'A' + 1;
+        }
     }
 
-    if (strncasecmp(*bind, "tab", 3) == 0)
+    if (strncasecmp(*bind, "tab", 3) == 0) {
         return T_KEY_TAB;
+    }
 
-    if (strncasecmp(*bind, "page", 4) == 0)
+    if (strncasecmp(*bind, "page", 4) == 0) {
         return len == 6 ? KEY_PPAGE : KEY_NPAGE;
+    }
 
     return -1;
 }
@@ -304,8 +307,9 @@ int settings_load(struct user_settings *s, const char *patharg)
         if (!file_exists(path)) {
             FILE *fp = fopen(path, "w");
 
-            if (fp == NULL)
+            if (fp == NULL) {
                 return -1;
+            }
 
             fclose(fp);
         }
@@ -324,18 +328,18 @@ int settings_load(struct user_settings *s, const char *patharg)
 
         int time = 24;
 
-        if ( config_setting_lookup_int(setting, ui_strings.time_format, &time) ) {
+        if (config_setting_lookup_int(setting, ui_strings.time_format, &time)) {
             if (time == 12) {
                 snprintf(s->timestamp_format, sizeof(s->timestamp_format), "%s", "%I:%M:%S %p");
                 snprintf(s->log_timestamp_format, sizeof(s->log_timestamp_format), "%s", "%Y/%m/%d [%I:%M:%S %p]");
             }
         }
 
-        if ( config_setting_lookup_string(setting, ui_strings.timestamp_format, &str) ) {
+        if (config_setting_lookup_string(setting, ui_strings.timestamp_format, &str)) {
             snprintf(s->timestamp_format, sizeof(s->timestamp_format), "%s", str);
         }
 
-        if ( config_setting_lookup_string(setting, ui_strings.log_timestamp_format, &str) ) {
+        if (config_setting_lookup_string(setting, ui_strings.log_timestamp_format, &str)) {
             snprintf(s->log_timestamp_format, sizeof(s->log_timestamp_format), "%s", str);
         }
 
@@ -367,80 +371,85 @@ int settings_load(struct user_settings *s, const char *patharg)
         config_setting_lookup_int(setting, ui_strings.history_size, &s->history_size);
         config_setting_lookup_int(setting, ui_strings.nodeslist_update_freq, &s->nodeslist_update_freq);
 
-        if ( config_setting_lookup_string(setting, ui_strings.line_join, &str) ) {
+        if (config_setting_lookup_string(setting, ui_strings.line_join, &str)) {
             snprintf(s->line_join, sizeof(s->line_join), "%s", str);
         }
 
-        if ( config_setting_lookup_string(setting, ui_strings.line_quit, &str) ) {
+        if (config_setting_lookup_string(setting, ui_strings.line_quit, &str)) {
             snprintf(s->line_quit, sizeof(s->line_quit), "%s", str);
         }
 
-        if ( config_setting_lookup_string(setting, ui_strings.line_alert, &str) ) {
+        if (config_setting_lookup_string(setting, ui_strings.line_alert, &str)) {
             snprintf(s->line_alert, sizeof(s->line_alert), "%s", str);
         }
 
-        if ( config_setting_lookup_string(setting, ui_strings.line_normal, &str) ) {
+        if (config_setting_lookup_string(setting, ui_strings.line_normal, &str)) {
             snprintf(s->line_normal, sizeof(s->line_normal), "%s", str);
         }
 
-        config_setting_lookup_bool (setting, ui_strings.mplex_away, &s->mplex_away);
+        config_setting_lookup_bool(setting, ui_strings.mplex_away, &s->mplex_away);
 
-        if (config_setting_lookup_string (setting, ui_strings.mplex_away_note, &str)) {
-            snprintf (s->mplex_away_note, sizeof (s->mplex_away_note), "%s", str);
+        if (config_setting_lookup_string(setting, ui_strings.mplex_away_note, &str)) {
+            snprintf(s->mplex_away_note, sizeof(s->mplex_away_note), "%s", str);
         }
     }
 
     /* paths */
     if ((setting = config_lookup(cfg, tox_strings.self)) != NULL) {
-        if ( config_setting_lookup_string(setting, tox_strings.download_path, &str) ) {
+        if (config_setting_lookup_string(setting, tox_strings.download_path, &str)) {
             snprintf(s->download_path, sizeof(s->download_path), "%s", str);
             int len = strlen(s->download_path);
 
             /* make sure path ends with a '/' */
-            if (len >= sizeof(s->download_path) - 2)
+            if (len >= sizeof(s->download_path) - 2) {
                 s->download_path[0] = '\0';
-            else if (s->download_path[len - 1] != '/')
+            } else if (s->download_path[len - 1] != '/') {
                 strcat(&s->download_path[len - 1], "/");
+            }
         }
 
-        if ( config_setting_lookup_string(setting, tox_strings.chatlogs_path, &str) ) {
+        if (config_setting_lookup_string(setting, tox_strings.chatlogs_path, &str)) {
             snprintf(s->chatlogs_path, sizeof(s->chatlogs_path), "%s", str);
             int len = strlen(s->chatlogs_path);
 
-            if (len >= sizeof(s->chatlogs_path) - 2)
+            if (len >= sizeof(s->chatlogs_path) - 2) {
                 s->chatlogs_path[0] = '\0';
-            else if (s->chatlogs_path[len - 1] != '/')
+            } else if (s->chatlogs_path[len - 1] != '/') {
                 strcat(&s->chatlogs_path[len - 1], "/");
+            }
         }
 
-        if ( config_setting_lookup_string(setting, tox_strings.avatar_path, &str) ) {
+        if (config_setting_lookup_string(setting, tox_strings.avatar_path, &str)) {
             snprintf(s->avatar_path, sizeof(s->avatar_path), "%s", str);
             int len = strlen(str);
 
-            if (len >= sizeof(s->avatar_path))
+            if (len >= sizeof(s->avatar_path)) {
                 s->avatar_path[0] = '\0';
+            }
         }
 
 #ifdef PYTHON
 
-        if ( config_setting_lookup_string(setting, tox_strings.autorun_path, &str) ) {
+        if (config_setting_lookup_string(setting, tox_strings.autorun_path, &str)) {
             snprintf(s->autorun_path, sizeof(s->autorun_path), "%s", str);
             int len = strlen(str);
 
-            if (len >= sizeof(s->autorun_path) - 2)
+            if (len >= sizeof(s->autorun_path) - 2) {
                 s->autorun_path[0] = '\0';
-            else if (s->autorun_path[len - 1] != '/')
+            } else if (s->autorun_path[len - 1] != '/') {
                 strcat(&s->autorun_path[len - 1], "/");
+            }
         }
 
 #endif
 
-        if ( config_setting_lookup_string(setting, tox_strings.password_eval, &str) ) {
+        if (config_setting_lookup_string(setting, tox_strings.password_eval, &str)) {
             snprintf(s->password_eval, sizeof(s->password_eval), "%s", str);
             int len = strlen(str);
 
-            if (len >= sizeof(s->password_eval))
+            if (len >= sizeof(s->password_eval)) {
                 s->password_eval[0] = '\0';
+            }
         }
     }
 
@@ -448,38 +457,49 @@ int settings_load(struct user_settings *s, const char *patharg)
     if ((setting = config_lookup(cfg, key_strings.self)) != NULL) {
         const char *tmp = NULL;
 
-        if (config_setting_lookup_string(setting, key_strings.next_tab, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.next_tab, &tmp)) {
             set_key_binding(&s->key_next_tab, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.prev_tab, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.prev_tab, &tmp)) {
             set_key_binding(&s->key_prev_tab, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.scroll_line_up, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.scroll_line_up, &tmp)) {
             set_key_binding(&s->key_scroll_line_up, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.scroll_line_down, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.scroll_line_down, &tmp)) {
             set_key_binding(&s->key_scroll_line_down, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.half_page_up, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.half_page_up, &tmp)) {
             set_key_binding(&s->key_half_page_up, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.half_page_down, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.half_page_down, &tmp)) {
             set_key_binding(&s->key_half_page_down, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.page_bottom, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.page_bottom, &tmp)) {
             set_key_binding(&s->key_page_bottom, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.peer_list_up, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.peer_list_up, &tmp)) {
             set_key_binding(&s->key_peer_list_up, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.peer_list_down, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.peer_list_down, &tmp)) {
             set_key_binding(&s->key_peer_list_down, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.toggle_peerlist, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.toggle_peerlist, &tmp)) {
             set_key_binding(&s->key_toggle_peerlist, &tmp);
+        }
 
-        if (config_setting_lookup_string(setting, key_strings.toggle_pastemode, &tmp))
+        if (config_setting_lookup_string(setting, key_strings.toggle_pastemode, &tmp)) {
             set_key_binding(&s->key_toggle_pastemode, &tmp);
+        }
     }
 
 #ifdef AUDIO
@@ -499,52 +519,60 @@ int settings_load(struct user_settings *s, const char *patharg)
 #ifdef SOUND_NOTIFY
 
     if ((setting = config_lookup(cfg, sound_strings.self)) != NULL) {
-        if ( (config_setting_lookup_string(setting, sound_strings.notif_error, &str) != CONFIG_TRUE) ||
-                !set_sound(notif_error, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if ((config_setting_lookup_string(setting, sound_strings.notif_error, &str) != CONFIG_TRUE) ||
+                !set_sound(notif_error, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(notif_error, PACKAGE_DATADIR "/sounds/ToxicError.wav");
+            }
         }
 
-        if ( !config_setting_lookup_string(setting, sound_strings.user_log_in, &str) ||
-                !set_sound(user_log_in, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if (!config_setting_lookup_string(setting, sound_strings.user_log_in, &str) ||
+                !set_sound(user_log_in, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(user_log_in, PACKAGE_DATADIR "/sounds/ToxicContactOnline.wav");
+            }
         }
 
-        if ( !config_setting_lookup_string(setting, sound_strings.user_log_out, &str) ||
-                !set_sound(user_log_out, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if (!config_setting_lookup_string(setting, sound_strings.user_log_out, &str) ||
+                !set_sound(user_log_out, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(user_log_out, PACKAGE_DATADIR "/sounds/ToxicContactOffline.wav");
+            }
         }
 
-        if ( !config_setting_lookup_string(setting, sound_strings.call_incoming, &str) ||
-                !set_sound(call_incoming, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if (!config_setting_lookup_string(setting, sound_strings.call_incoming, &str) ||
+                !set_sound(call_incoming, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(call_incoming, PACKAGE_DATADIR "/sounds/ToxicIncomingCall.wav");
+            }
         }
 
-        if ( !config_setting_lookup_string(setting, sound_strings.call_outgoing, &str) ||
-                !set_sound(call_outgoing, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if (!config_setting_lookup_string(setting, sound_strings.call_outgoing, &str) ||
+                !set_sound(call_outgoing, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(call_outgoing, PACKAGE_DATADIR "/sounds/ToxicOutgoingCall.wav");
+            }
         }
 
-        if ( !config_setting_lookup_string(setting, sound_strings.generic_message, &str) ||
-                !set_sound(generic_message, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if (!config_setting_lookup_string(setting, sound_strings.generic_message, &str) ||
+                !set_sound(generic_message, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(generic_message, PACKAGE_DATADIR "/sounds/ToxicRecvMessage.wav");
+            }
         }
 
-        if ( !config_setting_lookup_string(setting, sound_strings.transfer_pending, &str) ||
-                !set_sound(transfer_pending, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if (!config_setting_lookup_string(setting, sound_strings.transfer_pending, &str) ||
+                !set_sound(transfer_pending, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(transfer_pending, PACKAGE_DATADIR "/sounds/ToxicTransferStart.wav");
+            }
         }
 
-        if ( !config_setting_lookup_string(setting, sound_strings.transfer_completed, &str) ||
-                !set_sound(transfer_completed, str) ) {
-            if (str && strcasecmp(str, NO_SOUND) != 0)
+        if (!config_setting_lookup_string(setting, sound_strings.transfer_completed, &str) ||
+                !set_sound(transfer_completed, str)) {
+            if (str && strcasecmp(str, NO_SOUND) != 0) {
                 set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/ToxicTransferComplete.wav");
+            }
         }
     } else {
         set_sound(notif_error, PACKAGE_DATADIR "/sounds/ToxicError.wav");
diff --git a/src/term_mplex.c b/src/term_mplex.c
index bb1f910..f70c810 100644
--- a/src/term_mplex.c
+++ b/src/term_mplex.c
@@ -80,108 +80,118 @@ static char prev_note [TOX_MAX_STATUS_MESSAGE_LENGTH] = "";
 static pthread_mutex_t status_lock;
 static pthread_t mplex_tid;
 
-void lock_status ()
+void lock_status()
 {
-    pthread_mutex_lock (&status_lock);
+    pthread_mutex_lock(&status_lock);
 }
 
-void unlock_status ()
+void unlock_status()
 {
-    pthread_mutex_unlock (&status_lock);
+    pthread_mutex_unlock(&status_lock);
 }
 
-static char *read_into_dyn_buffer (FILE *stream)
+static char *read_into_dyn_buffer(FILE *stream)
 {
     const char *input_ptr = NULL;
     char *dyn_buffer = NULL;
     int dyn_buffer_size = 1; /* account for the \0 */
 
-    while ((input_ptr = fgets (buffer, BUFFER_SIZE, stream)) != NULL) {
-        int length = dyn_buffer_size + strlen (input_ptr);
+    while ((input_ptr = fgets(buffer, BUFFER_SIZE, stream)) != NULL) {
+        int length = dyn_buffer_size + strlen(input_ptr);
 
-        if (dyn_buffer)
-            dyn_buffer = (char *) realloc (dyn_buffer, length);
-        else
-            dyn_buffer = (char *) malloc (length);
+        if (dyn_buffer) {
+            dyn_buffer = (char *) realloc(dyn_buffer, length);
+        } else {
+            dyn_buffer = (char *) malloc(length);
+        }
 
-        strcpy (dyn_buffer + dyn_buffer_size - 1, input_ptr);
+        strcpy(dyn_buffer + dyn_buffer_size - 1, input_ptr);
         dyn_buffer_size = length;
     }
 
     return dyn_buffer;
 }
 
-static char *extract_socket_path (const char *info)
+static char *extract_socket_path(const char *info)
 {
     const char *search_str = " Socket";
-    const char *pos = strstr (info, search_str);
+    const char *pos = strstr(info, search_str);
     char *end = NULL;
     char *path = NULL;
 
-    if (!pos)
+    if (!pos) {
         return NULL;
+    }
 
-    pos += strlen (search_str);
-    pos = strchr (pos, PATH_SEP_C);
+    pos += strlen(search_str);
+    pos = strchr(pos, PATH_SEP_C);
 
-    if (!pos)
+    if (!pos) {
         return NULL;
+    }
 
-    end = strchr (pos, '\n');
+    end = strchr(pos, '\n');
 
-    if (!end)
+    if (!end) {
         return NULL;
+    }
 
     *end = '\0';
-    end = strrchr (pos, '.');
+    end = strrchr(pos, '.');
 
-    if (!end)
+    if (!end) {
         return NULL;
+    }
 
-    path = (char *) malloc (end - pos + 1);
+    path = (char *) malloc(end - pos + 1);
     *end = '\0';
-    return strcpy (path, pos);
+    return strcpy(path, pos);
 }
 
-static int detect_gnu_screen ()
+static int detect_gnu_screen()
 {
     FILE *session_info_stream = NULL;
     char *socket_name = NULL, *socket_path = NULL;
     char *dyn_buffer = NULL;
 
-    socket_name = getenv ("STY");
+    socket_name = getenv("STY");
 
-    if (!socket_name)
+    if (!socket_name) {
         goto nomplex;
+    }
 
-    session_info_stream = popen ("env LC_ALL=C screen -ls", "r");
+    session_info_stream = popen("env LC_ALL=C screen -ls", "r");
 
-    if (!session_info_stream)
+    if (!session_info_stream) {
         goto nomplex;
+    }
 
-    dyn_buffer = read_into_dyn_buffer (session_info_stream);
+    dyn_buffer = read_into_dyn_buffer(session_info_stream);
 
-    if (!dyn_buffer)
+    if (!dyn_buffer) {
         goto nomplex;
+    }
 
-    pclose (session_info_stream);
+    pclose(session_info_stream);
     session_info_stream = NULL;
 
-    socket_path = extract_socket_path (dyn_buffer);
+    socket_path = extract_socket_path(dyn_buffer);
 
-    if (!socket_path)
+    if (!socket_path) {
         goto nomplex;
+    }
 
-    free (dyn_buffer);
+    free(dyn_buffer);
     dyn_buffer = NULL;
 
-    if (strlen(socket_path) + strlen(PATH_SEP_S) + strlen(socket_name) >= sizeof(mplex_data))
+    if (strlen(socket_path) + strlen(PATH_SEP_S) + strlen(socket_name) >= sizeof(mplex_data)) {
         goto nomplex;
+    }
 
-    strcpy (mplex_data, socket_path);
-    strcat (mplex_data, PATH_SEP_S);
-    strcat (mplex_data, socket_name);
-    free (socket_path);
+    strcpy(mplex_data, socket_path);
+    strcat(mplex_data, PATH_SEP_S);
+    strcat(mplex_data, socket_name);
+    free(socket_path);
     socket_path = NULL;
 
     mplex = MPLEX_SCREEN;
@@ -189,33 +199,38 @@ static int detect_gnu_screen ()
 
 nomplex:
 
-    if (session_info_stream)
-        pclose (session_info_stream);
+    if (session_info_stream) {
+        pclose(session_info_stream);
+    }
 
-    if (dyn_buffer)
-        free (dyn_buffer);
+    if (dyn_buffer) {
+        free(dyn_buffer);
+    }
 
-    if (socket_path)
+    if (socket_path) {
         free(socket_path);
+    }
 
     return 0;
 }
 
-static int detect_tmux ()
+static int detect_tmux()
 {
-    char *tmux_env = getenv ("TMUX"), *pos;
+    char *tmux_env = getenv("TMUX"), *pos;
 
-    if (!tmux_env)
+    if (!tmux_env) {
         return 0;
+    }
 
     /* find second separator */
-    pos = strrchr (tmux_env, ',');
+    pos = strrchr(tmux_env, ',');
 
-    if (!pos)
+    if (!pos) {
         return 0;
+    }
 
     /* store the session id for later use */
-    snprintf (mplex_data, sizeof(mplex_data), "$%s", pos + 1);
+    snprintf(mplex_data, sizeof(mplex_data), "$%s", pos + 1);
     mplex = MPLEX_TMUX;
     return 1;
 }
@@ -228,92 +243,102 @@ static int detect_tmux ()
    Returns 1 if present, 0 otherwise. This value can be used to determine
    whether an auto-away detection timer is needed.
  */
-static int detect_mplex ()
+static int detect_mplex()
 {
     /* try screen, and if fails try tmux */
-    return detect_gnu_screen () || detect_tmux ();
+    return detect_gnu_screen() || detect_tmux();
 }
 
 /* Detects gnu screen session attached/detached by examining permissions of
    the session's unix socket.
  */
-static int gnu_screen_is_detached ()
+static int gnu_screen_is_detached()
 {
-    if (mplex != MPLEX_SCREEN)
+    if (mplex != MPLEX_SCREEN) {
         return 0;
+    }
 
     struct stat sb;
 
-    if (stat (mplex_data, &sb) != 0)
+    if (stat(mplex_data, &sb) != 0) {
         return 0;
+    }
 
     /* execution permission (x) means attached */
-    return ! (sb.st_mode & S_IXUSR);
+    return !(sb.st_mode & S_IXUSR);
 }
 
 /* Detects tmux attached/detached by getting session data and finding the
    current session's entry.
  */
-static int tmux_is_detached ()
+static int tmux_is_detached()
 {
-    if (mplex != MPLEX_TMUX)
+    if (mplex != MPLEX_TMUX) {
         return 0;
+    }
 
     FILE *session_info_stream = NULL;
     char *dyn_buffer = NULL, *search_str = NULL;
     char *entry_pos;
     int detached;
-    const int numstr_len = strlen (mplex_data);
+    const int numstr_len = strlen(mplex_data);
 
     /* get the number of attached clients for each session */
-    session_info_stream = popen ("tmux list-sessions -F \"#{session_id} #{session_attached}\"", "r");
+    session_info_stream = popen("tmux list-sessions -F \"#{session_id} #{session_attached}\"", "r");
 
-    if (!session_info_stream)
+    if (!session_info_stream) {
         goto fail;
+    }
 
-    dyn_buffer = read_into_dyn_buffer (session_info_stream);
+    dyn_buffer = read_into_dyn_buffer(session_info_stream);
 
-    if (!dyn_buffer)
+    if (!dyn_buffer) {
         goto fail;
+    }
 
-    pclose (session_info_stream);
+    pclose(session_info_stream);
     session_info_stream = NULL;
 
     /* prepare search string, for finding the current session's entry */
-    search_str = (char *) malloc (numstr_len + 2);
+    search_str = (char *) malloc(numstr_len + 2);
     search_str[0] = '\n';
-    strcpy (search_str + 1, mplex_data);
+    strcpy(search_str + 1, mplex_data);
 
     /* do the search */
-    if (strncmp (dyn_buffer, search_str + 1, numstr_len) == 0)
+    if (strncmp(dyn_buffer, search_str + 1, numstr_len) == 0) {
         entry_pos = dyn_buffer;
-    else
-        entry_pos = strstr (dyn_buffer, search_str);
+    } else {
+        entry_pos = strstr(dyn_buffer, search_str);
+    }
 
-    if (! entry_pos)
+    if (! entry_pos) {
         goto fail;
+    }
 
-    entry_pos = strchr (entry_pos, ' ') + 1;
-    detached = strncmp (entry_pos, "0\n", 2) == 0;
+    entry_pos = strchr(entry_pos, ' ') + 1;
+    detached = strncmp(entry_pos, "0\n", 2) == 0;
 
-    free (search_str);
+    free(search_str);
     search_str = NULL;
 
-    free (dyn_buffer);
+    free(dyn_buffer);
     dyn_buffer = NULL;
 
     return detached;
 
 fail:
 
-    if (session_info_stream)
-        pclose (session_info_stream);
+    if (session_info_stream) {
+        pclose(session_info_stream);
+    }
 
-    if (dyn_buffer)
-        free (dyn_buffer);
+    if (dyn_buffer) {
+        free(dyn_buffer);
+    }
 
-    if (search_str)
-        free (search_str);
+    if (search_str) {
+        free(search_str);
+    }
 
     return 0;
 }
@@ -327,24 +352,25 @@ fail:
    sample its state and update away status according to attached/detached state
    of the mplex.
  */
-static int mplex_is_detached ()
+static int mplex_is_detached()
 {
-    return gnu_screen_is_detached ()  ||  tmux_is_detached ();
+    return gnu_screen_is_detached()  ||  tmux_is_detached();
 }
 
-static void mplex_timer_handler (Tox *m)
+static void mplex_timer_handler(Tox *m)
 {
     TOX_USER_STATUS current_status, new_status;
     const char *new_note;
 
-    if (mplex == MPLEX_NONE)
+    if (mplex == MPLEX_NONE) {
         return;
+    }
 
-    int detached = mplex_is_detached ();
+    int detached = mplex_is_detached();
 
-    pthread_mutex_lock (&Winthread.lock);
-    current_status = tox_self_get_status (m);
-    pthread_mutex_unlock (&Winthread.lock);
+    pthread_mutex_lock(&Winthread.lock);
+    current_status = tox_self_get_status(m);
+    pthread_mutex_unlock(&Winthread.lock);
 
     if (auto_away_active && current_status == TOX_USER_STATUS_AWAY && !detached) {
         auto_away_active = false;
@@ -354,25 +380,26 @@ static void mplex_timer_handler (Tox *m)
         auto_away_active = true;
         prev_status = current_status;
         new_status = TOX_USER_STATUS_AWAY;
-        pthread_mutex_lock (&Winthread.lock);
+        pthread_mutex_lock(&Winthread.lock);
         size_t slen = tox_self_get_status_message_size(m);
-        tox_self_get_status_message (m, (uint8_t *) prev_note);
+        tox_self_get_status_message(m, (uint8_t *) prev_note);
         prev_note[slen] = '\0';
-        pthread_mutex_unlock (&Winthread.lock);
+        pthread_mutex_unlock(&Winthread.lock);
         new_note = user_settings->mplex_away_note;
-    } else
+    } else {
         return;
+    }
 
     char argv[3][MAX_STR_SIZE];
-    strcpy (argv[0], "/status");
-    strcpy (argv[1], (new_status == TOX_USER_STATUS_AWAY ? "away" :
-                      new_status == TOX_USER_STATUS_BUSY ? "busy" : "online"));
+    strcpy(argv[0], "/status");
+    strcpy(argv[1], (new_status == TOX_USER_STATUS_AWAY ? "away" :
+                     new_status == TOX_USER_STATUS_BUSY ? "busy" : "online"));
     argv[2][0] = '\"';
-    strcpy (argv[2] + 1, new_note);
-    strcat (argv[2], "\"");
-    pthread_mutex_lock (&Winthread.lock);
-    cmd_status (prompt->chatwin->history, prompt, m, 2, argv);
-    pthread_mutex_unlock (&Winthread.lock);
+    strcpy(argv[2] + 1, new_note);
+    strcat(argv[2], "\"");
+    pthread_mutex_lock(&Winthread.lock);
+    cmd_status(prompt->chatwin->history, prompt, m, 2, argv);
+    pthread_mutex_unlock(&Winthread.lock);
 }
 
 /* Time in seconds between calls to mplex_timer_handler */
@@ -388,20 +415,24 @@ void *mplex_timer_thread(void *data)
     }
 }
 
-int init_mplex_away_timer (Tox *m)
+int init_mplex_away_timer(Tox *m)
 {
-    if (! detect_mplex ())
+    if (! detect_mplex()) {
         return 0;
+    }
 
-    if (! user_settings->mplex_away)
+    if (! user_settings->mplex_away) {
         return 0;
+    }
 
     /* status access mutex */
-    if (pthread_mutex_init (&status_lock, NULL) != 0)
+    if (pthread_mutex_init(&status_lock, NULL) != 0) {
         return -1;
+    }
 
-    if (pthread_create(&mplex_tid, NULL, mplex_timer_thread, (void *) m) != 0)
+    if (pthread_create(&mplex_tid, NULL, mplex_timer_thread, (void *) m) != 0) {
         return -1;
+    }
 
     return 0;
 }
diff --git a/src/term_mplex.h b/src/term_mplex.h
index ce9387e..cab03ea 100644
--- a/src/term_mplex.h
+++ b/src/term_mplex.h
@@ -27,9 +27,9 @@
    yes, it initializes a timer which periodically checks the attached/detached
    state of the terminal and updates away status accordingly.
  */
-int init_mplex_away_timer (Tox *m);
+int init_mplex_away_timer(Tox *m);
 
-void lock_status ();
-void unlock_status ();
+void lock_status();
+void unlock_status();
 
 #endif /* #define TERM_MPLEX_H */
diff --git a/src/toxic.c b/src/toxic.c
index 7f2a4f8..452bad3 100644
--- a/src/toxic.c
+++ b/src/toxic.c
@@ -229,8 +229,9 @@ static void init_term(void)
         start_color();
 
         if (user_settings->colour_theme == NATIVE_COLS) {
-            if (assume_default_colors(-1, -1) == OK)
+            if (assume_default_colors(-1, -1) == OK) {
                 bg_color = -1;
+            }
         }
 
         init_pair(0, COLOR_WHITE, COLOR_BLACK);
@@ -267,13 +268,15 @@ static void queue_init_message(const char *msg, ...)
 
     char **new_msgs = realloc(init_messages.msgs, sizeof(char *) * init_messages.num);
 
-    if (new_msgs == NULL)
+    if (new_msgs == NULL) {
         exit_toxic_err("Failed in queue_init_message", FATALERR_MEMORY);
+    }
 
     new_msgs[i] = malloc(MAX_STR_SIZE);
 
-    if (new_msgs[i] == NULL)
+    if (new_msgs[i] == NULL) {
         exit_toxic_err("Failed in queue_init_message", FATALERR_MEMORY);
+    }
 
     snprintf(new_msgs[i], MAX_STR_SIZE, "%s", frmt_msg);
     init_messages.msgs = new_msgs;
@@ -282,13 +285,15 @@ static void queue_init_message(const char *msg, ...)
 /* called after messages have been printed to prompt and are no longer needed */
 static void cleanup_init_messages(void)
 {
-    if (init_messages.num <= 0)
+    if (init_messages.num <= 0) {
         return;
+    }
 
     int i;
 
-    for (i = 0; i < init_messages.num; ++i)
+    for (i = 0; i < init_messages.num; ++i) {
         free(init_messages.msgs[i]);
+    }
 
     free(init_messages.msgs);
 }
@@ -297,8 +302,9 @@ static void print_init_messages(ToxWindow *toxwin)
 {
     int i;
 
-    for (i = 0; i < init_messages.num; ++i)
+    for (i = 0; i < init_messages.num; ++i) {
         line_info_add(toxwin, NULL, NULL, NULL, SYS_MSG, 0, 0, init_messages.msgs[i]);
+    }
 }
 
 static void load_friendlist(Tox *m)
@@ -358,8 +364,9 @@ static int password_prompt(char *buf, int size)
     nflags.c_lflag &= ~ECHO;
     nflags.c_lflag |= ECHONL;
 
-    if (tcsetattr(fileno(stdin), TCSANOW, &nflags) != 0)
+    if (tcsetattr(fileno(stdin), TCSANOW, &nflags) != 0) {
         return 0;
+    }
 
     const char *p = fgets(buf, size, stdin);
     int len = strlen(buf);
@@ -367,8 +374,9 @@ static int password_prompt(char *buf, int size)
     /* re-enable terminal echo */
     tcsetattr(fileno(stdin), TCSANOW, &oflags);
 
-    if (p == NULL || len <= 1)
+    if (p == NULL || len <= 1) {
         return 0;
+    }
 
     /* eat overflowed stdin and return error */
     if (buf[--len] != '\n') {
@@ -438,15 +446,17 @@ static void first_time_encrypt(const char *msg)
         fflush(stdout);
 
         if (!strcasecmp(ch, "y\n") || !strcasecmp(ch, "n\n") || !strcasecmp(ch, "yes\n")
-                || !strcasecmp(ch, "no\n") || !strcasecmp(ch, "q\n"))
+                || !strcasecmp(ch, "no\n") || !strcasecmp(ch, "q\n")) {
             break;
+        }
 
     } while (fgets(ch, sizeof(ch), stdin));
 
     printf("\n");
 
-    if (ch[0] == 'q' || ch[0] == 'Q')
+    if (ch[0] == 'q' || ch[0] == 'Q') {
         exit(0);
+    }
 
     if (ch[0] == 'y' || ch[0] == 'Y') {
         int len = 0;
@@ -460,8 +470,9 @@ static void first_time_encrypt(const char *msg)
             len = password_prompt(user_password.pass, sizeof(user_password.pass));
             user_password.len = len;
 
-            if (strcasecmp(user_password.pass, "q") == 0)
+            if (strcasecmp(user_password.pass, "q") == 0) {
                 exit(0);
+            }
 
             if (string_is_empty(passconfirm) && (len < MIN_PASSWORD_LEN || len > MAX_PASSWORD_LEN)) {
                 printf("Password must be between %d and %d characters long. ", MIN_PASSWORD_LEN, MAX_PASSWORD_LEN);
@@ -604,11 +615,13 @@ static void init_tox_options(struct Tox_Options *tox_opts)
     tox_options_set_proxy_type(tox_opts, arg_opts.proxy_type);
     tox_options_set_tcp_port(tox_opts, arg_opts.tcp_port);
 
-    if (!tox_options_get_ipv6_enabled(tox_opts))
+    if (!tox_options_get_ipv6_enabled(tox_opts)) {
         queue_init_message("Forcing IPv4 connection");
+    }
 
-    if (tox_options_get_tcp_port(tox_opts))
+    if (tox_options_get_tcp_port(tox_opts)) {
         queue_init_message("TCP relaying enabled on port %d", tox_options_get_tcp_port(tox_opts));
+    }
 
     if (tox_options_get_proxy_type(tox_opts) != TOX_PROXY_TYPE_NONE) {
         tox_options_set_proxy_port(tox_opts, arg_opts.proxy_port);
@@ -662,14 +675,16 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
             exit_toxic_err("failed in load_tox", FATALERR_ENCRYPT);
         }
 
-        if (arg_opts.unencrypt_data && is_encrypted)
+        if (arg_opts.unencrypt_data && is_encrypted) {
             queue_init_message("Data file '%s' has been unencrypted", data_path);
-        else if (arg_opts.unencrypt_data)
+        } else if (arg_opts.unencrypt_data) {
             queue_init_message("Warning: passed --unencrypt-data option with unencrypted data file '%s'", data_path);
+        }
 
         if (is_encrypted) {
-            if (!arg_opts.unencrypt_data)
+            if (!arg_opts.unencrypt_data) {
                 user_password.data_is_encrypted = true;
+            }
 
             size_t pwlen = 0;
             int pweval = user_settings->password_eval[0];
@@ -746,18 +761,21 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
 
         fclose(fp);
     } else {   /* Data file does not/should not exist */
-        if (file_exists(data_path))
+        if (file_exists(data_path)) {
             exit_toxic_err("failed in load_tox", FATALERR_FILEOP);
+        }
 
         tox_options_set_savedata_type(tox_opts, TOX_SAVEDATA_TYPE_NONE);
 
         m = tox_new(tox_opts, new_err);
 
-        if (m == NULL)
+        if (m == NULL) {
             return NULL;
+        }
 
-        if (store_data(m, data_path) == -1)
+        if (store_data(m, data_path) == -1) {
             exit_toxic_err("failed in load_tox", FATALERR_FILEOP);
+        }
     }
 
     return m;
@@ -768,8 +786,9 @@ static Tox *load_toxic(char *data_path)
     TOX_ERR_OPTIONS_NEW options_new_err;
     struct Tox_Options *tox_opts = tox_options_new(&options_new_err);
 
-    if (!tox_opts)
+    if (!tox_opts) {
         exit_toxic_err("tox_options_new returned fatal error", options_new_err);
+    }
 
     init_tox_options(tox_opts);
 
@@ -782,18 +801,21 @@ static Tox *load_toxic(char *data_path)
         m = load_tox(data_path, tox_opts, &new_err);
     }
 
-    if (!m)
+    if (!m) {
         exit_toxic_err("tox_new returned fatal error", new_err);
+    }
 
-    if (new_err != TOX_ERR_NEW_OK)
+    if (new_err != TOX_ERR_NEW_OK) {
         queue_init_message("tox_new returned non-fatal error %d", new_err);
+    }
 
     init_tox_callbacks(m);
     load_friendlist(m);
     load_blocklist(BLOCK_FILE);
 
-    if (tox_self_get_name_size(m) == 0)
+    if (tox_self_get_name_size(m) == 0) {
         tox_self_set_name(m, (uint8_t *) "Toxic User", strlen("Toxic User"), NULL);
+    }
 
     tox_options_free(tox_opts);
     return m;
@@ -854,8 +876,9 @@ void *thread_cqueue(void *data)
             ToxWindow *toxwin = get_window_ptr(i);
 
             if (toxwin != NULL && toxwin->is_chat
-                    && get_friend_connection_status(toxwin->num) != TOX_CONNECTION_NONE)
+                    && get_friend_connection_status(toxwin->num) != TOX_CONNECTION_NONE) {
                 cqueue_try_send(toxwin, m);
+            }
         }
 
         pthread_mutex_unlock(&Winthread.lock);
@@ -956,8 +979,9 @@ static void parse_args(int argc, char *argv[])
             case 'c':
                 snprintf(arg_opts.config_path, sizeof(arg_opts.config_path), "%s", optarg);
 
-                if (!file_exists(arg_opts.config_path))
+                if (!file_exists(arg_opts.config_path)) {
                     queue_init_message("Config file not found");
+                }
 
                 break;
 
@@ -973,22 +997,26 @@ static void parse_args(int argc, char *argv[])
             case 'f':
                 arg_opts.use_custom_data = 1;
 
-                if (DATA_FILE)
+                if (DATA_FILE) {
                     free(DATA_FILE);
+                }
 
-                if (BLOCK_FILE)
+                if (BLOCK_FILE) {
                     free(BLOCK_FILE);
+                }
 
                 DATA_FILE = malloc(strlen(optarg) + 1);
                 strcpy(DATA_FILE, optarg);
 
-                if (DATA_FILE == NULL)
+                if (DATA_FILE == NULL) {
                     exit_toxic_err("failed in parse_args", FATALERR_MEMORY);
+                }
 
                 BLOCK_FILE = malloc(strlen(optarg) + strlen("-blocklist") + 1);
 
-                if (BLOCK_FILE == NULL)
+                if (BLOCK_FILE == NULL) {
                     exit_toxic_err("failed in parse_args", FATALERR_MEMORY);
+                }
 
                 strcpy(BLOCK_FILE, optarg);
                 strcat(BLOCK_FILE, "-blocklist");
@@ -1010,13 +1038,15 @@ static void parse_args(int argc, char *argv[])
                 arg_opts.proxy_type = TOX_PROXY_TYPE_SOCKS5;
                 snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);
 
-                if (++optind > argc || argv[optind - 1][0] == '-')
+                if (++optind > argc || argv[optind - 1][0] == '-') {
                     exit_toxic_err("Proxy error", FATALERR_PROXY);
+                }
 
                 port = strtol(argv[optind - 1], NULL, 10);
 
-                if (port <= 0 || port > MAX_PORT_RANGE)
+                if (port <= 0 || port > MAX_PORT_RANGE) {
                     exit_toxic_err("Proxy error", FATALERR_PROXY);
+                }
 
                 arg_opts.proxy_port = port;
                 break;
@@ -1025,13 +1055,15 @@ static void parse_args(int argc, char *argv[])
                 arg_opts.proxy_type = TOX_PROXY_TYPE_HTTP;
                 snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);
 
-                if (++optind > argc || argv[optind - 1][0] == '-')
+                if (++optind > argc || argv[optind - 1][0] == '-') {
                     exit_toxic_err("Proxy error", FATALERR_PROXY);
+                }
 
                 port = strtol(argv[optind - 1], NULL, 10);
 
-                if (port <= 0 || port > MAX_PORT_RANGE)
+                if (port <= 0 || port > MAX_PORT_RANGE) {
                     exit_toxic_err("Proxy error", FATALERR_PROXY);
+                }
 
                 arg_opts.proxy_port = port;
                 break;
@@ -1039,8 +1071,9 @@ static void parse_args(int argc, char *argv[])
             case 'r':
                 snprintf(arg_opts.nameserver_path, sizeof(arg_opts.nameserver_path), "%s", optarg);
 
-                if (!file_exists(arg_opts.nameserver_path))
+                if (!file_exists(arg_opts.nameserver_path)) {
                     queue_init_message("nameserver list not found");
+                }
 
                 break;
 
@@ -1051,8 +1084,9 @@ static void parse_args(int argc, char *argv[])
             case 'T':
                 port = strtol(optarg, NULL, 10);
 
-                if (port <= 0 || port > MAX_PORT_RANGE)
+                if (port <= 0 || port > MAX_PORT_RANGE) {
                     port = 14191;
+                }
 
                 arg_opts.tcp_port = port;
                 break;
@@ -1085,28 +1119,34 @@ static int rename_old_profile(const char *user_config_dir)
     char old_data_file[strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(OLD_DATA_NAME) + 1];
     snprintf(old_data_file, sizeof(old_data_file), "%s%s%s", user_config_dir, CONFIGDIR, OLD_DATA_NAME);
 
-    if (!file_exists(old_data_file))
+    if (!file_exists(old_data_file)) {
         return 0;
+    }
 
-    if (file_exists(DATA_FILE))
+    if (file_exists(DATA_FILE)) {
         return 0;
+    }
 
-    if (rename(old_data_file, DATA_FILE) != 0)
+    if (rename(old_data_file, DATA_FILE) != 0) {
         return -1;
+    }
 
     queue_init_message("Data file has been moved to %s", DATA_FILE);
 
     char old_data_blocklist[strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(OLD_DATA_BLOCKLIST_NAME) + 1];
     snprintf(old_data_blocklist, sizeof(old_data_blocklist), "%s%s%s", user_config_dir, CONFIGDIR, OLD_DATA_BLOCKLIST_NAME);
 
-    if (!file_exists(old_data_blocklist))
+    if (!file_exists(old_data_blocklist)) {
         return 0;
+    }
 
-    if (file_exists(BLOCK_FILE))
+    if (file_exists(BLOCK_FILE)) {
         return 0;
+    }
 
-    if (rename(old_data_blocklist, BLOCK_FILE) != 0)
+    if (rename(old_data_blocklist, BLOCK_FILE) != 0) {
         return -1;
+    }
 
     return 0;
 }
@@ -1117,13 +1157,15 @@ static int rename_old_profile(const char *user_config_dir)
  */
 static void init_default_data_files(void)
 {
-    if (arg_opts.use_custom_data)
+    if (arg_opts.use_custom_data) {
         return;
+    }
 
     char *user_config_dir = get_user_config_dir();
 
-    if (user_config_dir == NULL)
+    if (user_config_dir == NULL) {
         exit_toxic_err("failed in init_default_data_files()", FATALERR_FILEOP);
+    }
 
     int config_err = create_user_config_dirs(user_config_dir);
 
@@ -1131,14 +1173,16 @@ static void init_default_data_files(void)
         DATA_FILE = strdup(DATANAME);
         BLOCK_FILE = strdup(BLOCKNAME);
 
-        if (DATA_FILE == NULL || BLOCK_FILE == NULL)
+        if (DATA_FILE == NULL || BLOCK_FILE == NULL) {
             exit_toxic_err("failed in init_default_data_files()", FATALERR_MEMORY);
+        }
     } else {
         DATA_FILE = malloc(strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(DATANAME) + 1);
         BLOCK_FILE = malloc(strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(BLOCKNAME) + 1);
 
-        if (DATA_FILE == NULL || BLOCK_FILE == NULL)
+        if (DATA_FILE == NULL || BLOCK_FILE == NULL) {
             exit_toxic_err("failed in init_default_data_files()", FATALERR_MEMORY);
+        }
 
         strcpy(DATA_FILE, user_config_dir);
         strcat(DATA_FILE, CONFIGDIR);
@@ -1150,8 +1194,9 @@ static void init_default_data_files(void)
     }
 
     /* For backwards compatibility with old toxic profile names. TODO: remove this some day */
-    if (rename_old_profile(user_config_dir) == -1)
+    if (rename_old_profile(user_config_dir) == -1) {
         queue_init_message("Warning: Profile backwards compatibility failed.");
+    }
 
     free(user_config_dir);
 }
@@ -1174,8 +1219,9 @@ int main(int argc, char **argv)
     parse_args(argc, argv);
 
     /* Use the -b flag to enable stderr */
-    if (!arg_opts.debug)
+    if (!arg_opts.debug) {
         freopen("/dev/null", "w", stderr);
+    }
 
     if (arg_opts.encrypt_data && arg_opts.unencrypt_data) {
         arg_opts.encrypt_data = 0;
@@ -1190,17 +1236,19 @@ int main(int argc, char **argv)
 
     bool datafile_exists = file_exists(DATA_FILE);
 
-    if (!datafile_exists && !arg_opts.unencrypt_data)
+    if (!datafile_exists && !arg_opts.unencrypt_data) {
         first_time_encrypt("Creating new data file. Would you like to encrypt it? Y/n (q to quit)");
-    else if (arg_opts.encrypt_data)
+    } else if (arg_opts.encrypt_data) {
         first_time_encrypt("Encrypt existing data file? Y/n (q to quit)");
+    }
 
 
     /* init user_settings struct and load settings from conf file */
     user_settings = calloc(1, sizeof(struct user_settings));
 
-    if (user_settings == NULL)
+    if (user_settings == NULL) {
         exit_toxic_err("failed in main", FATALERR_MEMORY);
+    }
 
     const char *p = arg_opts.config_path[0] ? arg_opts.config_path : NULL;
 
@@ -1221,15 +1269,17 @@ int main(int argc, char **argv)
 
 #ifdef X11
 
-    if (init_xtra(DnD_callback) == -1)
+    if (init_xtra(DnD_callback) == -1) {
         queue_init_message("X failed to initialize");
+    }
 
 #endif
 
     Tox *m = load_toxic(DATA_FILE);
 
-    if (arg_opts.encrypt_data && !datafile_exists)
+    if (arg_opts.encrypt_data && !datafile_exists) {
         arg_opts.encrypt_data = 0;
+    }
 
 
     init_term();
@@ -1239,15 +1289,18 @@ int main(int argc, char **argv)
     load_groups(prompt, m);
 
     /* thread for ncurses stuff */
-    if (pthread_mutex_init(&Winthread.lock, NULL) != 0)
+    if (pthread_mutex_init(&Winthread.lock, NULL) != 0) {
         exit_toxic_err("failed in main", FATALERR_MUTEX_INIT);
+    }
 
-    if (pthread_create(&Winthread.tid, NULL, thread_winref, (void *) m) != 0)
+    if (pthread_create(&Winthread.tid, NULL, thread_winref, (void *) m) != 0) {
         exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);
+    }
 
     /* thread for message queue */
-    if (pthread_create(&cqueue_thread.tid, NULL, thread_cqueue, (void *) m) != 0)
+    if (pthread_create(&cqueue_thread.tid, NULL, thread_cqueue, (void *) m) != 0) {
         exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);
+    }
 
 #ifdef AUDIO
 
@@ -1259,16 +1312,18 @@ int main(int argc, char **argv)
 #endif /* VIDEO */
 
     /* AV thread */
-    if (pthread_create(&av_thread.tid, NULL, thread_av, (void *) av) != 0)
+    if (pthread_create(&av_thread.tid, NULL, thread_av, (void *) av) != 0) {
         exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);
+    }
 
     set_primary_device(input, user_settings->audio_in_dev);
     set_primary_device(output, user_settings->audio_out_dev);
 
 #elif SOUND_NOTIFY
 
-    if ( init_devices() == de_InternalError )
+    if (init_devices() == de_InternalError) {
         queue_init_message("Failed to init audio devices");
+    }
 
 #endif /* AUDIO */
 
@@ -1282,8 +1337,9 @@ int main(int argc, char **argv)
     init_notify(60, 3000);
 
     /* screen/tmux auto-away timer */
-    if (init_mplex_away_timer(m) == -1)
+    if (init_mplex_away_timer(m) == -1) {
         queue_init_message("Failed to init mplex auto-away.");
+    }
 
     int nodeslist_ret = load_DHT_nodeslist();
 
@@ -1312,8 +1368,9 @@ int main(int argc, char **argv)
         if (timed_out(last_save, AUTOSAVE_FREQ)) {
             pthread_mutex_lock(&Winthread.lock);
 
-            if (store_data(m, DATA_FILE) != 0)
+            if (store_data(m, DATA_FILE) != 0) {
                 line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, RED, "WARNING: Failed to save to data file");
+            }
 
             pthread_mutex_unlock(&Winthread.lock);
 
diff --git a/src/toxic.h b/src/toxic.h
index c8cb87c..0dd1f04 100644
--- a/src/toxic.h
+++ b/src/toxic.h
@@ -96,8 +96,8 @@ typedef enum _FATAL_ERRS {
    Uncomment if necessary */
 /* #define URXVT_FIX */
 
-void lock_status ();
-void unlock_status ();
+void lock_status();
+void unlock_status();
 
 void exit_toxic_success(Tox *m);
 void exit_toxic_err(const char *errmsg, int errcode);
@@ -127,7 +127,7 @@ void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, u
                            void *userdata);
 void on_file_recv_chunk(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data,
                         size_t length, void *userdata);
-void on_file_control (Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FILE_CONTROL control, void *userdata);
+void on_file_control(Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FILE_CONTROL control, void *userdata);
 void on_file_recv(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint32_t kind, uint64_t file_size,
                   const uint8_t *filename, size_t filename_length, void *userdata);
 void on_typing_change(Tox *m, uint32_t friendnumber, bool is_typing, void *userdata);
diff --git a/src/toxic_strings.c b/src/toxic_strings.c
index cd93ecd..1ad8d47 100644
--- a/src/toxic_strings.c
+++ b/src/toxic_strings.c
@@ -33,8 +33,9 @@
 /* Adds char to line at pos. Return 0 on success, -1 if line buffer is full */
 int add_char_to_buf(ChatContext *ctx, wint_t ch)
 {
-    if (ctx->len >= MAX_STR_SIZE - 1)
+    if (ctx->len >= MAX_STR_SIZE - 1) {
         return -1;
+    }
 
     wmemmove(&ctx->line[ctx->pos + 1], &ctx->line[ctx->pos], ctx->len - ctx->pos);
     ctx->line[ctx->pos++] = ch;
@@ -46,8 +47,9 @@ int add_char_to_buf(ChatContext *ctx, wint_t ch)
 /* Deletes the character before pos. Return 0 on success, -1 if nothing to delete */
 int del_char_buf_bck(ChatContext *ctx)
 {
-    if (ctx->pos <= 0)
+    if (ctx->pos <= 0) {
         return -1;
+    }
 
     wmemmove(&ctx->line[ctx->pos - 1], &ctx->line[ctx->pos], ctx->len - ctx->pos);
     --ctx->pos;
@@ -59,8 +61,9 @@ int del_char_buf_bck(ChatContext *ctx)
 /* Deletes the character at pos. Return 0 on success, -1 if nothing to delete. */
 int del_char_buf_frnt(ChatContext *ctx)
 {
-    if (ctx->pos >= ctx->len)
+    if (ctx->pos >= ctx->len) {
         return -1;
+    }
 
     wmemmove(&ctx->line[ctx->pos], &ctx->line[ctx->pos + 1], ctx->len - ctx->pos - 1);
     ctx->line[--ctx->len] = L'\0';
@@ -72,8 +75,9 @@ int del_char_buf_frnt(ChatContext *ctx)
    Return 0 on success, -1 if noting to discard. */
 int discard_buf(ChatContext *ctx)
 {
-    if (ctx->pos <= 0)
+    if (ctx->pos <= 0) {
         return -1;
+    }
 
     ctx->yank_len = ctx->pos;
     wmemcpy(ctx->yank, ctx->line, ctx->yank_len);
@@ -92,8 +96,9 @@ int discard_buf(ChatContext *ctx)
    Return 0 on success, -1 if nothing to kill. */
 int kill_buf(ChatContext *ctx)
 {
-    if (ctx->len <= ctx->pos)
+    if (ctx->len <= ctx->pos) {
         return -1;
+    }
 
     ctx->yank_len = ctx->len - ctx->pos;
     wmemcpy(ctx->yank, &ctx->line[ctx->pos], ctx->yank_len);
@@ -109,11 +114,13 @@ int kill_buf(ChatContext *ctx)
    Return 0 on success, -1 if yank buffer is empty or too long */
 int yank_buf(ChatContext *ctx)
 {
-    if (!ctx->yank[0])
+    if (!ctx->yank[0]) {
         return -1;
+    }
 
-    if (ctx->yank_len + ctx->len >= MAX_STR_SIZE)
+    if (ctx->yank_len + ctx->len >= MAX_STR_SIZE) {
         return -1;
+    }
 
     wmemmove(&ctx->line[ctx->pos + ctx->yank_len], &ctx->line[ctx->pos], ctx->len - ctx->pos);
     wmemcpy(&ctx->line[ctx->pos], ctx->yank, ctx->yank_len);
@@ -130,8 +137,9 @@ int yank_buf(ChatContext *ctx)
    Return 0 on success, -1 if nothing to delete */
 int del_word_buf(ChatContext *ctx)
 {
-    if (ctx->len == 0 || ctx->pos == 0)
+    if (ctx->len == 0 || ctx->pos == 0) {
         return -1;
+    }
 
     int i = ctx->pos, count = 0;
 
@@ -169,17 +177,20 @@ void reset_buf(ChatContext *ctx)
 /* Removes trailing spaces and newlines from line. */
 void rm_trailing_spaces_buf(ChatContext *ctx)
 {
-    if (ctx->len <= 0)
+    if (ctx->len <= 0) {
         return;
+    }
 
-    if (ctx->line[ctx->len - 1] != ' ' && ctx->line[ctx->len - 1] != L'¶')
+    if (ctx->line[ctx->len - 1] != ' ' && ctx->line[ctx->len - 1] != L'¶') {
         return;
+    }
 
     int i;
 
     for (i = ctx->len - 1; i >= 0; --i) {
-        if (ctx->line[i] != ' ' && ctx->line[i] != L'¶')
+        if (ctx->line[i] != ' ' && ctx->line[i] != L'¶') {
             break;
+        }
     }
 
     ctx->len = i + 1;
@@ -195,8 +206,9 @@ static void shift_hist_back(ChatContext *ctx)
     int i;
     int n = MAX_LINE_HIST - HIST_PURGE;
 
-    for (i = 0; i < n; ++i)
+    for (i = 0; i < n; ++i) {
         wmemcpy(ctx->ln_history[i], ctx->ln_history[i + HIST_PURGE], MAX_STR_SIZE);
+    }
 
     ctx->hst_tot = n;
 }
@@ -204,11 +216,13 @@ static void shift_hist_back(ChatContext *ctx)
 /* adds a line to the ln_history buffer at hst_pos and sets hst_pos to end of history. */
 void add_line_to_hist(ChatContext *ctx)
 {
-    if (ctx->len >= MAX_STR_SIZE)
+    if (ctx->len >= MAX_STR_SIZE) {
         return;
+    }
 
-    if (ctx->hst_tot >= MAX_LINE_HIST)
+    if (ctx->hst_tot >= MAX_LINE_HIST) {
         shift_hist_back(ctx);
+    }
 
     ++ctx->hst_tot;
     ctx->hst_pos = ctx->hst_tot;
@@ -248,8 +262,9 @@ void strsubst(char *str, char old, char new)
     int i;
 
     for (i = 0; str[i] != '\0'; ++i)
-        if (str[i] == old)
+        if (str[i] == old) {
             str[i] = new;
+        }
 }
 
 void wstrsubst(wchar_t *str, wchar_t old, wchar_t new)
@@ -257,6 +272,7 @@ void wstrsubst(wchar_t *str, wchar_t old, wchar_t new)
     int i;
 
     for (i = 0; str[i] != L'\0'; ++i)
-        if (str[i] == old)
+        if (str[i] == old) {
             str[i] = new;
+        }
 }
diff --git a/src/video_call.c b/src/video_call.c
index 6b30df7..483a027 100644
--- a/src/video_call.c
+++ b/src/video_call.c
@@ -41,15 +41,15 @@
 
 #define default_video_bit_rate 5000
 
-void receive_video_frame_cb( ToxAV *av, uint32_t friend_number,
-                             uint16_t width, uint16_t height,
-                             uint8_t const *y, uint8_t const *u, uint8_t const *v,
-                             int32_t ystride, int32_t ustride, int32_t vstride,
-                             void *user_data );
+void receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
+                            uint16_t width, uint16_t height,
+                            uint8_t const *y, uint8_t const *u, uint8_t const *v,
+                            int32_t ystride, int32_t ustride, int32_t vstride,
+                            void *user_data);
 
-void video_bit_rate_status_cb( ToxAV *av, uint32_t friend_number, uint32_t video_bit_rate, void *user_data);
+void video_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_t video_bit_rate, void *user_data);
 
-static void print_err (ToxWindow *self, const char *error_str)
+static void print_err(ToxWindow *self, const char *error_str)
 {
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", error_str);
 }
@@ -62,13 +62,13 @@ ToxAV *init_video(ToxWindow *self, Tox *tox)
     CallControl.video_bit_rate = 0;
     CallControl.video_frame_duration = 10;
 
-    if ( !CallControl.av ) {
+    if (!CallControl.av) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video failed to init with ToxAV instance");
 
         return NULL;
     }
 
-    if ( init_video_devices(CallControl.av) == vde_InternalError ) {
+    if (init_video_devices(CallControl.av) == vde_InternalError) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init video devices");
 
         return NULL;
@@ -89,8 +89,9 @@ void terminate_video()
 
         stop_video_transmission(this_call, i);
 
-        if ( this_call->vout_idx != -1 )
+        if (this_call->vout_idx != -1) {
             close_video_device(vdt_output, this_call->vout_idx);
+        }
     }
 
     terminate_video_devices();
@@ -104,18 +105,19 @@ void read_video_device_callback(int16_t width, int16_t height, const uint8_t *y,
     TOXAV_ERR_SEND_FRAME error;
 
     /* Drop frame if video sending is disabled */
-    if ( CallControl.video_bit_rate == 0 || this_call->vin_idx == -1 ) {
+    if (CallControl.video_bit_rate == 0 || this_call->vin_idx == -1) {
         line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video frame dropped.");
         return;
     }
 
-    if ( toxav_video_send_frame(CallControl.av, friend_number, width, height, y, u, v, &error ) == false ) {
+    if (toxav_video_send_frame(CallControl.av, friend_number, width, height, y, u, v, &error) == false) {
         line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to send video frame");
 
-        if ( error == TOXAV_ERR_SEND_FRAME_NULL )
+        if (error == TOXAV_ERR_SEND_FRAME_NULL) {
             line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to capture video frame");
-        else if ( error == TOXAV_ERR_SEND_FRAME_INVALID )
+        } else if (error == TOXAV_ERR_SEND_FRAME_INVALID) {
             line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare video frame");
+        }
     }
 }
 
@@ -129,24 +131,24 @@ void write_video_device_callback(uint32_t friend_number, uint16_t width, uint16_
 
 int start_video_transmission(ToxWindow *self, ToxAV *av, Call *call)
 {
-    if ( !self || !av) {
+    if (!self || !av) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare transmission");
         return -1;
     }
 
     CallControl.video_bit_rate = default_video_bit_rate;
 
-    if ( toxav_video_set_bit_rate(CallControl.av, self->num, CallControl.video_bit_rate, NULL) == false ) {
+    if (toxav_video_set_bit_rate(CallControl.av, self->num, CallControl.video_bit_rate, NULL) == false) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set video bit rate");
         return -1;
     }
 
-    if ( open_primary_video_device(vdt_input, &call->vin_idx) != vde_None ) {
+    if (open_primary_video_device(vdt_input, &call->vin_idx) != vde_None) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open input video device!");
         return -1;
     }
 
-    if ( register_video_device_callback(self->num, call->vin_idx, read_video_device_callback, &self->num) != vde_None ) {
+    if (register_video_device_callback(self->num, call->vin_idx, read_video_device_callback, &self->num) != vde_None) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to register input video handler!");
         return -1;
     }
@@ -159,7 +161,7 @@ int stop_video_transmission(Call *call, int friend_number)
     CallControl.video_bit_rate = 0;
     toxav_video_set_bit_rate(CallControl.av, friend_number, CallControl.video_bit_rate, NULL);
 
-    if ( call->vin_idx != -1 ) {
+    if (call->vin_idx != -1) {
         close_video_device(vdt_input, call->vin_idx);
         call->vin_idx = -1;
     }
@@ -196,8 +198,9 @@ void callback_recv_video_starting(uint32_t friend_number)
 {
     Call *this_call = &CallControl.calls[friend_number];
 
-    if ( this_call->vout_idx != -1 )
+    if (this_call->vout_idx != -1) {
         return;
+    }
 
     open_primary_video_device(vdt_output, &this_call->vout_idx);
 }
@@ -220,8 +223,8 @@ void callback_video_starting(uint32_t friend_number)
         size_t i;
 
         for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-            if ( windows[i].is_call && windows[i].num == friend_number ) {
-                if ( 0 != start_video_transmission(&windows[i], CallControl.av, this_call) ) {
+            if (windows[i].is_call && windows[i].num == friend_number) {
+                if (0 != start_video_transmission(&windows[i], CallControl.av, this_call)) {
                     line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
                     return;
                 }
@@ -249,54 +252,60 @@ void cmd_video(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[M
     const char *error_str;
     Call *this_call = &CallControl.calls[self->num];
 
-    if ( argc != 0 ) {
+    if (argc != 0) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !CallControl.av ) {
+    if (!CallControl.av) {
         error_str = "ToxAV not supported!";
         goto on_error;
     }
 
-    if ( !self->stb->connection ) {
+    if (!self->stb->connection) {
         error_str = "Friend is offline.";
         goto on_error;
     }
 
-    if ( !self->is_call ) {
+    if (!self->is_call) {
         error_str = "Not in call!";
         goto on_error;
     }
 
-    if ( this_call->vin_idx == -1 )
+    if (this_call->vin_idx == -1) {
         callback_video_starting(self->num);
-    else
+    } else {
         callback_video_end(self->num);
+    }
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str;
 
-    if ( argc != 1 ) {
-        if ( argc < 1 ) error_str = "Type must be specified!";
-        else error_str = "Only one argument allowed!";
+    if (argc != 1) {
+        if (argc < 1) {
+            error_str = "Type must be specified!";
+        } else {
+            error_str = "Only one argument allowed!";
+        }
 
         goto on_error;
     }
 
     VideoDeviceType type;
 
-    if ( strcasecmp(argv[1], "in") == 0 ) /* Input devices */
+    if (strcasecmp(argv[1], "in") == 0) { /* Input devices */
         type = vdt_input;
+    }
 
-    else if ( strcasecmp(argv[1], "out") == 0 ) /* Output devices */
+    else if (strcasecmp(argv[1], "out") == 0) { /* Output devices */
         type = vdt_output;
+    }
 
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
@@ -307,7 +316,7 @@ void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, c
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 /* This changes primary video device only */
@@ -315,21 +324,27 @@ void cmd_change_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc,
 {
     const char *error_str;
 
-    if ( argc != 2 ) {
-        if ( argc < 1 ) error_str = "Type must be specified!";
-        else if ( argc < 2 ) error_str = "Must have id!";
-        else error_str = "Only two arguments allowed!";
+    if (argc != 2) {
+        if (argc < 1) {
+            error_str = "Type must be specified!";
+        } else if (argc < 2) {
+            error_str = "Must have id!";
+        } else {
+            error_str = "Only two arguments allowed!";
+        }
 
         goto on_error;
     }
 
     VideoDeviceType type;
 
-    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+    if (strcmp(argv[1], "in") == 0) { /* Input devices */
         type = vdt_input;
+    }
 
-    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+    else if (strcmp(argv[1], "out") == 0) { /* Output devices */
         type = vdt_output;
+    }
 
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
@@ -340,40 +355,46 @@ void cmd_change_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc,
     char *end;
     long int selection = strtol(argv[2], &end, 10);
 
-    if ( *end ) {
+    if (*end) {
         error_str = "Invalid input";
         goto on_error;
     }
 
-    if ( set_primary_video_device(type, selection) == vde_InvalidSelection ) {
+    if (set_primary_video_device(type, selection) == vde_InvalidSelection) {
         error_str = "Invalid selection!";
         goto on_error;
     }
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     const char *error_str;
 
-    if ( argc != 2 ) {
-        if ( argc < 1 ) error_str = "Type must be specified!";
-        else if ( argc < 2 ) error_str = "Must have id!";
-        else error_str = "Only two arguments allowed!";
+    if (argc != 2) {
+        if (argc < 1) {
+            error_str = "Type must be specified!";
+        } else if (argc < 2) {
+            error_str = "Must have id!";
+        } else {
+            error_str = "Only two arguments allowed!";
+        }
 
         goto on_error;
     }
 
     VideoDeviceType type;
 
-    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+    if (strcmp(argv[1], "in") == 0) { /* Input devices */
         type = vdt_input;
+    }
 
-    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+    else if (strcmp(argv[1], "out") == 0) { /* Output devices */
         type = vdt_output;
+    }
 
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
@@ -384,23 +405,23 @@ void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, ch
     char *end;
     long int selection = strtol(argv[2], &end, 10);
 
-    if ( *end ) {
+    if (*end) {
         error_str = "Invalid input";
         goto on_error;
     }
 
-    if ( video_selection_valid(type, selection) == vde_InvalidSelection ) {
+    if (video_selection_valid(type, selection) == vde_InvalidSelection) {
         error_str = "Invalid selection!";
         goto on_error;
     }
 
     /* If call is active, change device */
-    if ( self->is_call ) {
+    if (self->is_call) {
         Call *this_call = &CallControl.calls[self->num];
 
-        if ( this_call->ttas ) {
+        if (this_call->ttas) {
 
-            if ( type == vdt_output ) {
+            if (type == vdt_output) {
             } else {
                 /* TODO: check for failure */
                 close_video_device(vdt_input, this_call->vin_idx);
@@ -414,15 +435,16 @@ void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, ch
 
     return;
 on_error:
-    print_err (self, error_str);
+    print_err(self, error_str);
 }
 
 void stop_video_stream(ToxWindow *self)
 {
     Call *this_call = &CallControl.calls[self->num];
 
-    if (this_call && this_call->vin_idx != -1)
+    if (this_call && this_call->vin_idx != -1) {
         stop_video_transmission(this_call, self->num);
+    }
 }
 
 #endif
diff --git a/src/video_device.c b/src/video_device.c
index e899735..3afc0f7 100644
--- a/src/video_device.c
+++ b/src/video_device.c
@@ -187,8 +187,9 @@ VideoDeviceError init_video_devices()
 
 #if defined(__OSX__)
 
-    if ( osx_video_init((char **)video_devices_names[vdt_input], &size[vdt_input]) != 0 )
+    if (osx_video_init((char **)video_devices_names[vdt_input], &size[vdt_input]) != 0) {
         return vde_InternalError;
+    }
 
 #else /* not __OSX__*/
 
@@ -199,14 +200,14 @@ VideoDeviceError init_video_devices()
 
         fd = open(device_address, O_RDWR | O_NONBLOCK, 0);
 
-        if ( fd == -1 ) {
+        if (fd == -1) {
             break;
         } else {
             struct v4l2_capability cap;
             char *video_input_name;
 
             /* Query V4L for capture capabilities */
-            if ( -1 != ioctl(fd, VIDIOC_QUERYCAP, &cap) ) {
+            if (-1 != ioctl(fd, VIDIOC_QUERYCAP, &cap)) {
                 video_input_name = (char *)malloc(strlen((const char *)cap.card) + strlen(device_address) + 4);
                 strcpy(video_input_name, (char *)cap.card);
                 strcat(video_input_name, " (");
@@ -232,13 +233,15 @@ VideoDeviceError init_video_devices()
     video_devices_names[vdt_output][0] = video_output_name;
 
     // Start poll thread
-    if ( pthread_mutex_init(&video_mutex, NULL) != 0 )
+    if (pthread_mutex_init(&video_mutex, NULL) != 0) {
         return vde_InternalError;
+    }
 
     pthread_t thread_id;
 
-    if ( pthread_create(&thread_id, NULL, video_thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0 )
+    if (pthread_create(&thread_id, NULL, video_thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0) {
         return vde_InternalError;
+    }
 
 #ifdef VIDEO
     av = av_;
@@ -262,8 +265,9 @@ VideoDeviceError terminate_video_devices()
         free((void *)video_devices_names[vdt_input][i]);
     }
 
-    if ( pthread_mutex_destroy(&video_mutex) != 0 )
+    if (pthread_mutex_destroy(&video_mutex) != 0) {
         return (VideoDeviceError) vde_InternalError;
+    }
 
 #ifdef __OSX__
     osx_video_release();
@@ -277,14 +281,16 @@ VideoDeviceError register_video_device_callback(int32_t friend_number, uint32_t
 {
 #if defined(__OSX__)
 
-    if ( size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx] )
+    if (size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx]) {
         return vde_InvalidSelection;
+    }
 
 #else /* not __OSX__ */
 
-    if ( size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx]
-            || !video_devices_running[vdt_input][device_idx]->fd )
+    if (size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx]
+            || !video_devices_running[vdt_input][device_idx]->fd) {
         return vde_InvalidSelection;
+    }
 
 #endif
 
@@ -299,7 +305,9 @@ VideoDeviceError register_video_device_callback(int32_t friend_number, uint32_t
 
 VideoDeviceError set_primary_video_device(VideoDeviceType type, int32_t selection)
 {
-    if ( size[type] <= selection || selection < 0 ) return vde_InvalidSelection;
+    if (size[type] <= selection || selection < 0) {
+        return vde_InvalidSelection;
+    }
 
     primary_video_device[type] = selection;
 
@@ -318,14 +326,16 @@ void get_primary_video_device_name(VideoDeviceType type, char *buf, int size)
 
 VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx)
 {
-    if ( size[type] <= selection || selection < 0 ) return vde_InvalidSelection;
+    if (size[type] <= selection || selection < 0) {
+        return vde_InvalidSelection;
+    }
 
     lock;
 
     uint32_t i, temp_idx = -1;
 
     for (i = 0; i < MAX_DEVICES; ++i) {
-        if ( !video_devices_running[type][i] ) {
+        if (!video_devices_running[type][i]) {
             temp_idx = i;
             break;
         }
@@ -337,7 +347,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
     }
 
     for (i = 0; i < MAX_DEVICES; i ++) { /* Check if any device has the same selection */
-        if ( video_devices_running[type][i] && video_devices_running[type][i]->selection == selection ) {
+        if (video_devices_running[type][i] && video_devices_running[type][i]->selection == selection) {
 
             video_devices_running[type][temp_idx] = video_devices_running[type][i];
             video_devices_running[type][i]->ref_count++;
@@ -350,18 +360,18 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
     VideoDevice *device = video_devices_running[type][temp_idx] = calloc(1, sizeof(VideoDevice));
     device->selection = selection;
 
-    if ( pthread_mutex_init(device->mutex, NULL) != 0 ) {
+    if (pthread_mutex_init(device->mutex, NULL) != 0) {
         free(device);
         unlock;
         return vde_InternalError;
     }
 
-    if ( type == vdt_input ) {
+    if (type == vdt_input) {
         video_thread_paused = true;
 
 #if defined(__OSX__)
 
-        if ( osx_video_open_device(selection, &device->video_width, &device->video_height) != 0 ) {
+        if (osx_video_open_device(selection, &device->video_width, &device->video_height) != 0) {
             free(device);
             unlock;
             return vde_FailedStart;
@@ -374,7 +384,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 
         device->fd = open(device_address, O_RDWR);
 
-        if ( device->fd == -1 ) {
+        if (device->fd == -1) {
             unlock;
             return vde_FailedStart;
         }
@@ -382,7 +392,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
         /* Obtain video device capabilities */
         struct v4l2_capability cap;
 
-        if ( -1 == xioctl(device->fd, VIDIOC_QUERYCAP, &cap) ) {
+        if (-1 == xioctl(device->fd, VIDIOC_QUERYCAP, &cap)) {
             close(device->fd);
             free(device);
             unlock;
@@ -396,7 +406,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
 
-        if ( -1 == xioctl(device->fd, VIDIOC_S_FMT, &fmt) ) {
+        if (-1 == xioctl(device->fd, VIDIOC_S_FMT, &fmt)) {
             close(device->fd);
             free(device);
             unlock;
@@ -413,14 +423,14 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         req.memory = V4L2_MEMORY_MMAP;
 
-        if ( -1 == xioctl(device->fd, VIDIOC_REQBUFS, &req) ) {
+        if (-1 == xioctl(device->fd, VIDIOC_REQBUFS, &req)) {
             close(device->fd);
             free(device);
             unlock;
             return vde_FailedStart;
         }
 
-        if ( req.count < 2 ) {
+        if (req.count < 2) {
             close(device->fd);
             free(device);
             unlock;
@@ -437,7 +447,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
             buf.memory = V4L2_MEMORY_MMAP;
             buf.index = i;
 
-            if ( -1 == xioctl(device->fd, VIDIOC_QUERYBUF, &buf) ) {
+            if (-1 == xioctl(device->fd, VIDIOC_QUERYBUF, &buf)) {
                 close(device->fd);
                 free(device);
                 unlock;
@@ -451,9 +461,10 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
                                             MAP_SHARED /* recommended */,
                                             device->fd, buf.m.offset);
 
-            if ( MAP_FAILED == device->buffers[i].start ) {
-                for (i = 0; i < buf.index; ++i)
+            if (MAP_FAILED == device->buffers[i].start) {
+                for (i = 0; i < buf.index; ++i) {
                     munmap(device->buffers[i].start, device->buffers[i].length);
+                }
 
                 close(device->fd);
                 free(device);
@@ -474,9 +485,10 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
             buf.memory = V4L2_MEMORY_MMAP;
             buf.index = i;
 
-            if ( -1 == xioctl(device->fd, VIDIOC_QBUF, &buf) ) {
-                for (i = 0; i < device->n_buffers; ++i)
+            if (-1 == xioctl(device->fd, VIDIOC_QBUF, &buf)) {
+                for (i = 0; i < device->n_buffers; ++i) {
                     munmap(device->buffers[i].start, device->buffers[i].length);
+                }
 
                 close(device->fd);
                 free(device);
@@ -488,7 +500,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
         /* Turn on video stream */
-        if ( -1 == xioctl(device->fd, VIDIOC_STREAMON, &type) ) {
+        if (-1 == xioctl(device->fd, VIDIOC_STREAMON, &type)) {
             close_video_device(vdt_input, temp_idx);
             unlock;
             return vde_FailedStart;
@@ -497,7 +509,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 #endif
 
         /* Create X11 window associated to device */
-        if ( (device->x_display = XOpenDisplay(NULL)) == NULL ) {
+        if ((device->x_display = XOpenDisplay(NULL)) == NULL) {
             close_video_device(vdt_input, temp_idx);
             unlock;
             return vde_FailedStart;
@@ -505,9 +517,9 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 
         int screen = DefaultScreen(device->x_display);
 
-        if ( !(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
-                                  device->video_width, device->video_height, 0, BlackPixel(device->x_display, screen),
-                                  BlackPixel(device->x_display, screen))) ) {
+        if (!(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
+                                 device->video_width, device->video_height, 0, BlackPixel(device->x_display, screen),
+                                 BlackPixel(device->x_display, screen)))) {
             close_video_device(vdt_input, temp_idx);
             unlock;
             return vde_FailedStart;
@@ -516,7 +528,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
         XStoreName(device->x_display, device->x_window, "Video Preview");
         XSelectInput(device->x_display, device->x_window, ExposureMask | ButtonPressMask | KeyPressMask);
 
-        if ( (device->x_gc = DefaultGC(device->x_display, screen)) == NULL ) {
+        if ((device->x_gc = DefaultGC(device->x_display, screen)) == NULL) {
             close_video_device(vdt_input, temp_idx);
             unlock;
             return vde_FailedStart;
@@ -537,7 +549,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
     } else { /* vdt_output */
 
         /* Create X11 window associated to device */
-        if ( (device->x_display = XOpenDisplay(NULL)) == NULL ) {
+        if ((device->x_display = XOpenDisplay(NULL)) == NULL) {
             close_video_device(vdt_output, temp_idx);
             unlock;
             return vde_FailedStart;
@@ -545,8 +557,8 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 
         int screen = DefaultScreen(device->x_display);
 
-        if ( !(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
-                                  100, 100, 0, BlackPixel(device->x_display, screen), BlackPixel(device->x_display, screen))) ) {
+        if (!(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
+                                 100, 100, 0, BlackPixel(device->x_display, screen), BlackPixel(device->x_display, screen)))) {
             close_video_device(vdt_output, temp_idx);
             unlock;
             return vde_FailedStart;
@@ -555,7 +567,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
         XStoreName(device->x_display, device->x_window, "Video Receive");
         XSelectInput(device->x_display, device->x_window, ExposureMask | ButtonPressMask | KeyPressMask);
 
-        if ( (device->x_gc = DefaultGC(device->x_display, screen)) == NULL ) {
+        if ((device->x_gc = DefaultGC(device->x_display, screen)) == NULL) {
             close_video_device(vdt_output, temp_idx);
             unlock;
             return vde_FailedStart;
@@ -586,14 +598,18 @@ __inline VideoDeviceError write_video_out(uint16_t width, uint16_t height,
 {
     VideoDevice *device = video_devices_running[vdt_output][0];
 
-    if ( !device ) return vde_DeviceNotActive;
+    if (!device) {
+        return vde_DeviceNotActive;
+    }
 
-    if ( !device->x_window ) return vde_DeviceNotActive;
+    if (!device->x_window) {
+        return vde_DeviceNotActive;
+    }
 
     pthread_mutex_lock(device->mutex);
 
     /* Resize X11 window to correct size */
-    if ( device->video_width != width || device->video_height != height ) {
+    if (device->video_width != width || device->video_height != height) {
         device->video_width = width;
         device->video_height = height;
         XResizeWindow(device->x_display, device->x_window, width, height);
@@ -638,7 +654,7 @@ __inline VideoDeviceError write_video_out(uint16_t width, uint16_t height,
     return vde_None;
 }
 
-void *video_thread_poll (void *arg) // TODO: maybe use thread for every input source
+void *video_thread_poll(void *arg)  // TODO: maybe use thread for every input source
 {
     /*
      * NOTE: We only need to poll input devices for data.
@@ -656,12 +672,13 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
 
         unlock;
 
-        if ( video_thread_paused ) usleep(10000); /* Wait for unpause. */
-        else {
+        if (video_thread_paused) {
+            usleep(10000);    /* Wait for unpause. */
+        } else {
             for (i = 0; i < size[vdt_input]; ++i) {
                 lock;
 
-                if ( video_devices_running[vdt_input][i] != NULL ) {
+                if (video_devices_running[vdt_input][i] != NULL) {
                     /* Obtain frame image data from device buffers */
                     VideoDevice *device = video_devices_running[vdt_input][i];
                     uint16_t video_width = device->video_width;
@@ -672,7 +689,7 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
 
 #if defined(__OSX__)
 
-                    if ( osx_video_read_device(y, u, v, &video_width, &video_height) != 0 ) {
+                    if (osx_video_read_device(y, u, v, &video_width, &video_height) != 0) {
                         unlock;
                         continue;
                     }
@@ -684,7 +701,7 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
                     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                     buf.memory = V4L2_MEMORY_MMAP;
 
-                    if ( -1 == ioctl(device->fd, VIDIOC_DQBUF, &buf) ) {
+                    if (-1 == ioctl(device->fd, VIDIOC_DQBUF, &buf)) {
                         unlock;
                         continue;
                     }
@@ -697,8 +714,9 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
 #endif
 
                     /* Send frame data to friend through ToxAV */
-                    if ( device->cb )
+                    if (device->cb) {
                         device->cb(video_width, video_height, y, u, v, device->cb_data);
+                    }
 
                     /* Convert YUV420 data to BGR */
                     uint8_t *img_data = malloc(video_width * video_height * 4);
@@ -732,7 +750,7 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
 
-                    if ( -1 == xioctl(device->fd, VIDIOC_QBUF, &buf) ) {
+                    if (-1 == xioctl(device->fd, VIDIOC_QBUF, &buf)) {
                         unlock;
                         continue;
                     }
@@ -753,34 +771,36 @@ void *video_thread_poll (void *arg) // TODO: maybe use thread for every input so
 
 VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx)
 {
-    if ( device_idx >= MAX_DEVICES ) return vde_InvalidSelection;
+    if (device_idx >= MAX_DEVICES) {
+        return vde_InvalidSelection;
+    }
 
     lock;
     VideoDevice *device = video_devices_running[type][device_idx];
     VideoDeviceError rc = vde_None;
 
-    if ( !device ) {
+    if (!device) {
         unlock;
         return vde_DeviceNotActive;
     }
 
     video_devices_running[type][device_idx] = NULL;
 
-    if ( !device->ref_count ) {
+    if (!device->ref_count) {
 
-        if ( type == vdt_input ) {
+        if (type == vdt_input) {
 #if defined(__OSX__)
 
             osx_video_close_device(device_idx);
 #else /* not __OSX__ */
             enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
-            if ( -1 == xioctl(device->fd, VIDIOC_STREAMOFF, &buf_type) ) {}
+            if (-1 == xioctl(device->fd, VIDIOC_STREAMOFF, &buf_type)) {}
 
             int i;
 
             for (i = 0; i < device->n_buffers; ++i) {
-                if ( -1 == munmap(device->buffers[i].start, device->buffers[i].length) ) {
+                if (-1 == munmap(device->buffers[i].start, device->buffers[i].length)) {
                 }
             }
 
@@ -807,7 +827,9 @@ VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx)
             free(device);
         }
 
-    } else device->ref_count--;
+    } else {
+        device->ref_count--;
+    }
 
     unlock;
     return rc;
@@ -817,8 +839,9 @@ void print_video_devices(ToxWindow *self, VideoDeviceType type)
 {
     int i;
 
-    for (i = 0; i < size[type]; ++i)
+    for (i = 0; i < size[type]; ++i) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%d: %s", i, video_devices_names[type][i]);
+    }
 
     return;
 }
diff --git a/src/video_device.h b/src/video_device.h
index ed84e53..12a5664 100644
--- a/src/video_device.h
+++ b/src/video_device.h
@@ -45,8 +45,8 @@ typedef enum VideoDeviceError {
     vde_CaptureError = -9,
 } VideoDeviceError;
 
-typedef void (*VideoDataHandleCallback) (int16_t width, int16_t height, const uint8_t *y, const uint8_t *u,
-        const uint8_t *v, void *data);
+typedef void (*VideoDataHandleCallback)(int16_t width, int16_t height, const uint8_t *y, const uint8_t *u,
+                                        const uint8_t *v, void *data);
 
 #ifdef VIDEO
 VideoDeviceError init_video_devices(ToxAV *av);
diff --git a/src/windows.c b/src/windows.c
index c879ed9..36c61ef 100644
--- a/src/windows.c
+++ b/src/windows.c
@@ -67,21 +67,24 @@ void on_connectionchange(Tox *m, uint32_t friendnumber, TOX_CONNECTION connectio
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onConnectionChange != NULL)
+        if (windows[i].onConnectionChange != NULL) {
             windows[i].onConnectionChange(&windows[i], m, friendnumber, connection_status);
+        }
     }
 }
 
 void on_typing_change(Tox *m, uint32_t friendnumber, bool is_typing, void *userdata)
 {
-    if (user_settings->show_typing_other == SHOW_TYPING_OFF)
+    if (user_settings->show_typing_other == SHOW_TYPING_OFF) {
         return;
+    }
 
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onTypingChange != NULL)
+        if (windows[i].onTypingChange != NULL) {
             windows[i].onTypingChange(&windows[i], m, friendnumber, is_typing);
+        }
     }
 }
 
@@ -94,8 +97,9 @@ void on_message(Tox *m, uint32_t friendnumber, TOX_MESSAGE_TYPE type, const uint
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onMessage != NULL)
+        if (windows[i].onMessage != NULL) {
             windows[i].onMessage(&windows[i], m, friendnumber, type, msg, length);
+        }
     }
 }
 
@@ -108,8 +112,9 @@ void on_nickchange(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onNickChange != NULL)
+        if (windows[i].onNickChange != NULL) {
             windows[i].onNickChange(&windows[i], m, friendnumber, nick, length);
+        }
     }
 
     store_data(m, DATA_FILE);
@@ -124,8 +129,9 @@ void on_statusmessagechange(Tox *m, uint32_t friendnumber, const uint8_t *string
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onStatusMessageChange != NULL)
+        if (windows[i].onStatusMessageChange != NULL) {
             windows[i].onStatusMessageChange(&windows[i], friendnumber, msg, length);
+        }
     }
 }
 
@@ -134,8 +140,9 @@ void on_statuschange(Tox *m, uint32_t friendnumber, TOX_USER_STATUS status, void
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onStatusChange != NULL)
+        if (windows[i].onStatusChange != NULL) {
             windows[i].onStatusChange(&windows[i], m, friendnumber, status);
+        }
     }
 }
 
@@ -144,8 +151,9 @@ void on_friendadded(Tox *m, uint32_t friendnumber, bool sort)
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onFriendAdded != NULL)
+        if (windows[i].onFriendAdded != NULL) {
             windows[i].onFriendAdded(&windows[i], m, friendnumber, sort);
+        }
     }
 
     store_data(m, DATA_FILE);
@@ -160,8 +168,9 @@ void on_groupmessage(Tox *m, uint32_t groupnumber, uint32_t peernumber, TOX_MESS
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onGroupMessage != NULL)
+        if (windows[i].onGroupMessage != NULL) {
             windows[i].onGroupMessage(&windows[i], m, groupnumber, peernumber, type, msg, length);
+        }
     }
 }
 
@@ -171,8 +180,9 @@ void on_groupinvite(Tox *m, uint32_t friendnumber, TOX_CONFERENCE_TYPE type, con
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onGroupInvite != NULL)
+        if (windows[i].onGroupInvite != NULL) {
             windows[i].onGroupInvite(&windows[i], m, friendnumber, type, (char *) group_pub_key, length);
+        }
     }
 }
 
@@ -181,8 +191,9 @@ void on_group_namelistchange(Tox *m, uint32_t groupnumber, void *userdata)
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onGroupNameListChange != NULL)
+        if (windows[i].onGroupNameListChange != NULL) {
             windows[i].onGroupNameListChange(&windows[i], m, groupnumber);
+        }
     }
 }
 
@@ -196,8 +207,9 @@ void on_group_peernamechange(Tox *m, uint32_t groupnumber, uint32_t peernumber,
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onGroupPeerNameChange != NULL)
+        if (windows[i].onGroupPeerNameChange != NULL) {
             windows[i].onGroupPeerNameChange(&windows[i], m, groupnumber, peernumber, nick, length);
+        }
     }
 }
 
@@ -210,8 +222,9 @@ void on_group_titlechange(Tox *m, uint32_t groupnumber, uint32_t peernumber, con
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onGroupTitleChange != NULL)
+        if (windows[i].onGroupTitleChange != NULL) {
             windows[i].onGroupTitleChange(&windows[i], m, groupnumber, peernumber, data, length);
+        }
     }
 }
 
@@ -220,8 +233,9 @@ void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, u
 {
     struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
 
-    if (!ft)
+    if (!ft) {
         return;
+    }
 
     if (ft->file_type == TOX_FILE_KIND_AVATAR) {
         on_avatar_chunk_request(m, ft, position, length);
@@ -231,8 +245,9 @@ void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, u
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onFileChunkRequest != NULL)
+        if (windows[i].onFileChunkRequest != NULL) {
             windows[i].onFileChunkRequest(&windows[i], m, friendnumber, filenumber, position, length);
+        }
     }
 }
 
@@ -241,14 +256,16 @@ void on_file_recv_chunk(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint
 {
     struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
 
-    if (!ft)
+    if (!ft) {
         return;
+    }
 
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onFileRecvChunk != NULL)
+        if (windows[i].onFileRecvChunk != NULL) {
             windows[i].onFileRecvChunk(&windows[i], m, friendnumber, filenumber, position, (char *) data, length);
+        }
     }
 }
 
@@ -257,8 +274,9 @@ void on_file_control(Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FIL
 {
     struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
 
-    if (!ft)
+    if (!ft) {
         return;
+    }
 
     if (ft->file_type == TOX_FILE_KIND_AVATAR) {
         on_avatar_file_control(m, ft, control);
@@ -268,8 +286,9 @@ void on_file_control(Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FIL
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onFileControl != NULL)
+        if (windows[i].onFileControl != NULL) {
             windows[i].onFileControl(&windows[i], m, friendnumber, filenumber, control);
+        }
     }
 }
 
@@ -296,27 +315,31 @@ void on_read_receipt(Tox *m, uint32_t friendnumber, uint32_t receipt, void *user
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onReadReceipt != NULL)
+        if (windows[i].onReadReceipt != NULL) {
             windows[i].onReadReceipt(&windows[i], m, friendnumber, receipt);
+        }
     }
 }
 /* CALLBACKS END */
 
 int add_window(Tox *m, ToxWindow w)
 {
-    if (LINES < 2)
+    if (LINES < 2) {
         return -1;
+    }
 
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; i++) {
-        if (windows[i].active)
+        if (windows[i].active) {
             continue;
+        }
 
         w.window = newwin(LINES - 2, COLS, 0, 0);
 
-        if (w.window == NULL)
+        if (w.window == NULL) {
             return -1;
+        }
 
 #ifdef URXVT_FIX
         /* Fixes text color problem on some terminals. */
@@ -324,8 +347,9 @@ int add_window(Tox *m, ToxWindow w)
 #endif
         windows[i] = w;
 
-        if (w.onInit)
+        if (w.onInit) {
             w.onInit(&w, m);
+        }
 
         ++num_active_windows;
 
@@ -337,8 +361,9 @@ int add_window(Tox *m, ToxWindow w)
 
 void set_active_window(int index)
 {
-    if (index < 0 || index >= MAX_WINDOWS_NUM)
+    if (index < 0 || index >= MAX_WINDOWS_NUM) {
         return;
+    }
 
     active_window = windows + index;
 }
@@ -351,16 +376,20 @@ void set_next_window(int ch)
 
     while (true) {
         if (ch == user_settings->key_next_tab) {
-            if (++active_window > end)
+            if (++active_window > end) {
                 active_window = windows;
-        } else if (--active_window < windows)
+            }
+        } else if (--active_window < windows) {
             active_window = end;
+        }
 
-        if (active_window->window)
+        if (active_window->window) {
             return;
+        }
 
-        if (active_window == inf)    /* infinite loop check */
+        if (active_window == inf) {  /* infinite loop check */
             exit_toxic_err("failed in set_next_window", FATALERR_INFLOOP);
+        }
     }
 }
 
@@ -381,8 +410,9 @@ ToxWindow *init_windows(Tox *m)
 {
     int n_prompt = add_window(m, new_prompt());
 
-    if (n_prompt == -1 || add_window(m, new_friendlist()) == -1)
+    if (n_prompt == -1 || add_window(m, new_friendlist()) == -1) {
         exit_toxic_err("failed in init_windows", FATALERR_WININIT);
+    }
 
     prompt = &windows[n_prompt];
     active_window = prompt;
@@ -401,14 +431,16 @@ void on_window_resize(void)
     getmaxyx(stdscr, y2, x2);
     y2 -= 2;
 
-    if (y2 <= 0 || x2 <= 0)
+    if (y2 <= 0 || x2 <= 0) {
         return;
+    }
 
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (!windows[i].active)
+        if (!windows[i].active) {
             continue;
+        }
 
         ToxWindow *w = &windows[i];
 
@@ -418,8 +450,9 @@ void on_window_resize(void)
             continue;
         }
 
-        if (w->help->active)
+        if (w->help->active) {
             wclear(w->help->win);
+        }
 
         if (w->is_groupchat) {
             delwin(w->chatwin->sidebar);
@@ -441,8 +474,9 @@ void on_window_resize(void)
         } else {
             w->chatwin->history = subwin(w->window, y2 - CHATBOX_HEIGHT + 1, x2, 0, 0);
 
-            if (!w->is_groupchat)
+            if (!w->is_groupchat) {
                 w->stb->topline = subwin(w->window, 2, x2, 0, 0);
+            }
         }
 
 #ifdef AUDIO
@@ -462,7 +496,9 @@ static void draw_window_tab(ToxWindow *toxwin)
 {
     pthread_mutex_lock(&Winthread.lock);
 
-    if (toxwin->alert != WINDOW_ALERT_NONE) attron(COLOR_PAIR(toxwin->alert));
+    if (toxwin->alert != WINDOW_ALERT_NONE) {
+        attron(COLOR_PAIR(toxwin->alert));
+    }
 
     pthread_mutex_unlock(&Winthread.lock);
 
@@ -471,7 +507,9 @@ static void draw_window_tab(ToxWindow *toxwin)
 
     pthread_mutex_lock(&Winthread.lock);
 
-    if (toxwin->alert != WINDOW_ALERT_NONE) attroff(COLOR_PAIR(toxwin->alert));
+    if (toxwin->alert != WINDOW_ALERT_NONE) {
+        attroff(COLOR_PAIR(toxwin->alert));
+    }
 
     pthread_mutex_unlock(&Winthread.lock);
 }
@@ -492,8 +530,9 @@ static void draw_bar(void)
     size_t i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (!windows[i].active)
+        if (!windows[i].active) {
             continue;
+        }
 
         if (windows + i == active_window)
 
@@ -543,19 +582,22 @@ void draw_active_window(Tox *m)
 #ifdef HAVE_WIDECHAR
     int status = wget_wch(stdscr, &ch);
 
-    if (status == ERR)
+    if (status == ERR) {
         return;
+    }
 
-    if (status == OK)
+    if (status == OK) {
         ltr = iswprint(ch);
-    else /* if (status == KEY_CODE_YES) */
+    } else { /* if (status == KEY_CODE_YES) */
         ltr = false;
+    }
 
 #else
     ch = getch();
 
-    if (ch == ERR)
+    if (ch == ERR) {
         return;
+    }
 
     /* TODO verify if this works */
     ltr = isprint(ch);
@@ -592,8 +634,9 @@ ToxWindow *get_window_ptr(int i)
 {
     ToxWindow *toxwin = NULL;
 
-    if (i >= 0 && i < MAX_WINDOWS_NUM && windows[i].active)
+    if (i >= 0 && i < MAX_WINDOWS_NUM && windows[i].active) {
         toxwin = &windows[i];
+    }
 
     return toxwin;
 }
diff --git a/src/xtra.c b/src/xtra.c
index 77c625d..8e2b059 100644
--- a/src/xtra.c
+++ b/src/xtra.c
@@ -76,7 +76,9 @@ Property read_property(Window s, Atom p)
 
     /* Keep trying to read the property until there are no bytes unread */
     do {
-        if (data) XFree(data);
+        if (data) {
+            XFree(data);
+        }
 
         XGetWindowProperty(Xtra.display, s,
                            p, 0,
@@ -98,7 +100,9 @@ Atom get_dnd_type(long *a, int l)
     int i = 0;
 
     for (; i < l; i ++) {
-        if (a[i] != XtraNil) return a[i]; /* Get first valid */
+        if (a[i] != XtraNil) {
+            return a[i];    /* Get first valid */
+        }
     }
 
     return XtraNil;
@@ -193,10 +197,11 @@ static void handle_xdnd_selection(XSelectionEvent *e)
     Property p = read_property(Xtra.proxy_window, XdndSelection);
     DropType dt;
 
-    if (strcmp(XGetAtomName(Xtra.display, p.read_type), "text/uri-list") == 0)
+    if (strcmp(XGetAtomName(Xtra.display, p.read_type), "text/uri-list") == 0) {
         dt = DT_file_list;
-    else /* text/uri-list */
+    } else { /* text/uri-list */
         dt = DT_plain;
+    }
 
 
     /* Call callback for every entry */
@@ -204,13 +209,18 @@ static void handle_xdnd_selection(XSelectionEvent *e)
         char *sptr;
         char *str = strtok_r((char *) p.data, "\n\r", &sptr);
 
-        if (str) Xtra.on_drop(str, dt);
-
-        while ((str = strtok_r(NULL, "\n\r", &sptr)))
+        if (str) {
             Xtra.on_drop(str, dt);
+        }
+
+        while ((str = strtok_r(NULL, "\n\r", &sptr))) {
+            Xtra.on_drop(str, dt);
+        }
     }
 
-    if (p.data) XFree(p.data);
+    if (p.data) {
+        XFree(p.data);
+    }
 }
 
 void *event_loop(void *p)
@@ -227,7 +237,9 @@ void *event_loop(void *p)
 
         XLockDisplay(Xtra.display);
 
-        if ((pending = XPending(Xtra.display))) XNextEvent(Xtra.display, &event);
+        if ((pending = XPending(Xtra.display))) {
+            XNextEvent(Xtra.display, &event);
+        }
 
         if (!pending) {
             XUnlockDisplay(Xtra.display);
@@ -238,13 +250,22 @@ void *event_loop(void *p)
         if (event.type == ClientMessage) {
             Atom type = event.xclient.message_type;
 
-            if      (type == XdndEnter)         handle_xdnd_enter(&event.xclient);
-            else if (type == XdndPosition)      handle_xdnd_position(&event.xclient);
-            else if (type == XdndDrop)          handle_xdnd_drop(&event.xclient);
-            else if (type == XtraTerminate)     break;
-        } else if (event.type == SelectionNotify) handle_xdnd_selection(&event.xselection);
+            if (type == XdndEnter) {
+                handle_xdnd_enter(&event.xclient);
+            } else if (type == XdndPosition) {
+                handle_xdnd_position(&event.xclient);
+            } else if (type == XdndDrop) {
+                handle_xdnd_drop(&event.xclient);
+            } else if (type == XtraTerminate) {
+                break;
+            }
+        } else if (event.type == SelectionNotify) {
+            handle_xdnd_selection(&event.xselection);
+        }
         /* AINNOBODYCANHANDLEDEMEVENTS*/
-        else XSendEvent(Xtra.display, Xtra.terminal_window, 0, 0, &event);
+        else {
+            XSendEvent(Xtra.display, Xtra.terminal_window, 0, 0, &event);
+        }
 
         XUnlockDisplay(Xtra.display);
     }
@@ -253,7 +274,9 @@ void *event_loop(void *p)
      * Please call xtra_terminate() at exit
      * otherwise HEWUSAGUDBOI happens
      */
-    if (Xtra.display) XCloseDisplay(Xtra.display);
+    if (Xtra.display) {
+        XCloseDisplay(Xtra.display);
+    }
 
     return (Xtra.display = NULL);
 }
@@ -262,19 +285,25 @@ int init_xtra(drop_callback d)
 {
     memset(&Xtra, 0, sizeof(Xtra));
 
-    if (!d) return -1;
-    else Xtra.on_drop = d;
+    if (!d) {
+        return -1;
+    } else {
+        Xtra.on_drop = d;
+    }
 
     XInitThreads();
 
-    if ( !(Xtra.display = XOpenDisplay(NULL))) return -1;
+    if (!(Xtra.display = XOpenDisplay(NULL))) {
+        return -1;
+    }
 
     Xtra.terminal_window = focused_window_id();
 
     /* OSX: if focused window is 0, it means toxic is ran from
      * native terminal and not X11 terminal window, silently exit */
-    if (!Xtra.terminal_window)
+    if (!Xtra.terminal_window) {
         return 0;
+    }
 
     {
         /* Create an invisible window which will act as proxy for the DnD operation. */
@@ -299,17 +328,18 @@ int init_xtra(drop_callback d)
                      XDefaultRootWindow(Xtra.display),
                      &root, &x, &y, &wht, &hht, &b, &d);
 
-        if (! (Xtra.proxy_window = XCreateWindow
-                                   (Xtra.display, Xtra.terminal_window,       /* Parent */
-                                    0, 0,                                     /* Position */
-                                    wht, hht,                                 /* Width + height */
-                                    0,                                        /* Border width */
-                                    CopyFromParent,                           /* Depth */
-                                    InputOnly,                                /* Class */
-                                    CopyFromParent,                           /* Visual */
-                                    CWEventMask | CWCursor,                   /* Value mask */
-                                    &attr)) )                                 /* Attributes for value mask */
+        if (!(Xtra.proxy_window = XCreateWindow
+                                  (Xtra.display, Xtra.terminal_window,       /* Parent */
+                                   0, 0,                                     /* Position */
+                                   wht, hht,                                 /* Width + height */
+                                   0,                                        /* Border width */
+                                   CopyFromParent,                           /* Depth */
+                                   InputOnly,                                /* Class */
+                                   CopyFromParent,                           /* Visual */
+                                   CWEventMask | CWCursor,                   /* Value mask */
+                                   &attr))) {                                /* Attributes for value mask */
             return -1;
+        }
     }
 
     XMapWindow(Xtra.display, Xtra.proxy_window);   /* Show window (sandwich) */
@@ -339,8 +369,9 @@ int init_xtra(drop_callback d)
 
     pthread_t id;
 
-    if (pthread_create(&id, NULL, event_loop, NULL) != 0)
+    if (pthread_create(&id, NULL, event_loop, NULL) != 0) {
         return -1;
+    }
 
     pthread_detach(id);
 
@@ -349,7 +380,9 @@ int init_xtra(drop_callback d)
 
 void terminate_xtra()
 {
-    if (!Xtra.display || !Xtra.terminal_window) return;
+    if (!Xtra.display || !Xtra.terminal_window) {
+        return;
+    }
 
     XEvent terminate = {
         .xclient = {
@@ -369,7 +402,9 @@ void terminate_xtra()
 
 long unsigned int focused_window_id()
 {
-    if (!Xtra.display) return 0;
+    if (!Xtra.display) {
+        return 0;
+    }
 
     Window focus;
     int revert;
diff --git a/src/xtra.h b/src/xtra.h
index ba380f2..0a4bd00 100644
--- a/src/xtra.h
+++ b/src/xtra.h
@@ -31,7 +31,7 @@ typedef enum {
 }
 DropType;
 
-typedef void (*drop_callback) (const char *, DropType);
+typedef void (*drop_callback)(const char *, DropType);
 
 int               init_xtra(drop_callback d);
 void              terminate_xtra();