Add config option to show real-time network info in UI

Profiling can be enabled with the -s run option

.github/workflows/ci.yml

@@ -18,6 +18,7 @@ jobs:
             libalut-dev
             libconfig-dev
             libcurl4-gnutls-dev
+            libmsgpack-dev
             libnotify-dev
             libopenal-dev
             libopus-dev
@@ -72,6 +73,7 @@ jobs:
             libalut-dev
             libconfig-dev
             libcurl4-gnutls-dev
+            libmsgpack-dev
             libncurses-dev
             libnotify-dev
             libopenal-dev
@@ -103,6 +105,7 @@ jobs:
               libnotify
               libpng
               libqrencode
+              msgpack
               ncurses
               openal
               python3

Makefile

@@ -14,7 +14,7 @@ LDFLAGS += ${USER_LDFLAGS}
 
 OBJ = autocomplete.o avatars.o bootstrap.o chat.o chat_commands.o configdir.o curl_util.o execute.o
 OBJ += file_transfers.o friendlist.o global_commands.o conference_commands.o conference.o help.o input.o line_info.o
-OBJ += log.o message_queue.o misc_tools.o name_lookup.o notify.o prompt.o qr_code.o settings.o
+OBJ += log.o message_queue.o misc_tools.o name_lookup.o netprof.o notify.o prompt.o qr_code.o settings.o
 OBJ += term_mplex.o toxic.o toxic_strings.o windows.o
 
 # Check if debug build is enabled

doc/toxic.conf.5

@@ -138,6 +138,11 @@ Show welcome message on startup\&. true or false
 Enable friend connection change notifications\&. true or false
 .RE
 .PP
+\fBshow_network_info\fR
+.RS 4
+Show network information in the UI home window\&. true or false
+.RE
+.PP
 \fBnodelist_update_freq\fR
 .RS 4
 How often in days to update the DHT nodes list\&. (integer; 0 to disable)

doc/toxic.conf.5.asc

@@ -87,6 +87,9 @@ OPTIONS
     *show_connection_msg*;;
         Enable friend connection change notifications. true or false
 
+    *show_network_info*;;
+        Show network information in the UI home window. true or false
+
     *nodelist_update_freq*;;
         How often in days to update the DHT nodes list. (integer; 0 to disable)
 

misc/toxic.conf.example

@@ -56,6 +56,9 @@ ui = {
   // true to show friend connection change messages on the home screen
   show_connection_msg=true;
 
+  // true to show network information in the UI home window
+  show_network_info=true;
+
   // How often in days to update the DHT nodes list. (0 to disable updates)
   nodeslist_update_freq=7;
 

script/build-minimal-static-toxic.sh

@@ -64,7 +64,6 @@ set -eu
 ARTIFACT_DIR="/artifact"
 TOXIC_SRC_DIR="/toxic"
 
-
 if [ ! -f /etc/os-release ] || ! grep -qi 'Alpine Linux' /etc/os-release
 then
   echo "Error: This script expects to be run on Alpine Linux."
@@ -115,6 +114,7 @@ apk add \
     libsodium-dev \
     libsodium-static \
     linux-headers \
+    msgpack-c-dev \
     ncurses-dev \
     ncurses-static \
     ncurses-terminfo \
@@ -137,10 +137,10 @@ mkdir -p "$BUILD_DIR"
 cd "$BUILD_DIR"
 
 # The git hash of the c-toxcore version we're using
-TOXCORE_VERSION="v0.2.13"
+TOXCORE_VERSION="v0.2.16"
 
 # The sha256sum of the c-toxcore tarball for TOXCORE_VERSION
-TOXCORE_HASH="67114fa57504c58b695f5dce8ef85124d555f2c3c353d0d2615e6d4845114ab8"
+TOXCORE_HASH="653aa42654b607f0940cecfac873e9ce55605119a90d1dc454d1090ff6ca29c0"
 
 TOXCORE_FILENAME="c-toxcore-$TOXCORE_VERSION.tar.gz"
 
@@ -169,8 +169,8 @@ cmake --build _build --target install
 # location with SSL_CERT_FILE env variable.
 cd "$BUILD_DIR"
 
-CURL_VERSION="7.80.0"
-CURL_HASH="dab997c9b08cb4a636a03f2f7f985eaba33279c1c52692430018fae4a4878dc7"
+CURL_VERSION="7.81.0"
+CURL_HASH="ac8e1087711084548d788ef18b9b732c8de887457b81f616fc681d1044b32f98"
 CURL_FILENAME="curl-$CURL_VERSION.tar.gz"
 
 wget --timeout=10 -O "$CURL_FILENAME" "https://curl.haxx.se/download/$CURL_FILENAME"
@@ -307,4 +307,3 @@ mv "$PREPARE_ARTIFACT_DIR" "$PREPARE_ARTIFACT_DIR/../$ARTIFACT_NAME"
 tar -cJf "$ARTIFACT_NAME.tar.xz" "$ARTIFACT_NAME"
 mv "$ARTIFACT_NAME.tar.xz" "$ARTIFACT_DIR"
 chmod 777 -R "$ARTIFACT_DIR"
-

src/chat.c

@@ -130,7 +130,7 @@ static void set_self_typingstatus(ToxWindow *self, Tox *m, bool is_typing)
 
     ChatContext *ctx = self->chatwin;
 
-    TOX_ERR_SET_TYPING err;
+    Tox_Err_Set_Typing err;
     tox_self_set_typing(m, self->num, is_typing, &err);
 
     if (err != TOX_ERR_SET_TYPING_OK) {

src/game_base.c

@@ -1129,7 +1129,7 @@ int game_packet_send(const GameData *game, const uint8_t *data, size_t length, G
     memcpy(packet + 1 + GAME_PACKET_HEADER_SIZE, data, length);
     packet_length += length;
 
-    TOX_ERR_FRIEND_CUSTOM_PACKET err;
+    Tox_Err_Friend_Custom_Packet err;
 
     if (!tox_friend_send_lossless_packet(game->tox, game->friend_number, packet, packet_length, &err)) {
         fprintf(stderr, "failed to send game packet: error %d\n", err);

src/line_info.c

@@ -143,11 +143,14 @@ static struct line_info *line_info_ret_queue(struct history *hst)
  */
 static int print_n_chars(WINDOW *win, const wchar_t *s, size_t n, int max_y)
 {
+    // we use an array to represent a single wchar in order to get around an ncurses
+    // bug with waddnwstr() that overreads the memory address by one byte when
+    // supplied with a single wchar.
+    wchar_t ch[2] = {0};
     bool newline = false;
-    wchar_t ch;
 
-    for (size_t i = 0; i < n && (ch = s[i]); ++i) {
-        if (ch == L'\n') {
+    for (size_t i = 0; i < n && (ch[0] = s[i]); ++i) {
+        if (ch[0] == L'\n') {
             newline = true;
 
             int x;
@@ -164,11 +167,11 @@ static int print_n_chars(WINDOW *win, const wchar_t *s, size_t n, int max_y)
 
         if (win) {
 #ifdef HAVE_WIDECHAR
-            waddnwstr(win, &ch, 1);
+            waddnwstr(win, ch, 1);
 #else
             char b;
 
-            if (wcstombs(&b, &ch, sizeof(char)) != 1) {
+            if (wcstombs(&b, ch, sizeof(char)) != 1) {
                 continue;
             }
 
@@ -345,22 +348,25 @@ static uint16_t line_info_add_msg(wchar_t *buf, size_t buf_size, const char *msg
         return 0;
     }
 
-    uint16_t width = 0;
-
     const wint_t wc_msg_len = mbs_to_wcs_buf(buf, msg, buf_size);
 
     if (wc_msg_len > 0 && wc_msg_len < buf_size) {
         buf[wc_msg_len] = L'\0';
-        width = (uint16_t) wcswidth(buf, wc_msg_len);
+        int width = wcswidth(buf, wc_msg_len);
+
+        if (width == -1) {  // the best we can do on failure is to fall back to strlen
+            width = strlen(msg);
+        }
+
+        return (uint16_t)width;
     } else {
         fprintf(stderr, "Failed to convert string '%s' to widechar\n", msg);
         const wchar_t *err = L"Failed to parse message";
-        width = wcslen(err);
+        uint16_t width = (uint16_t)wcslen(err);
         wmemcpy(buf, err, width);
         buf[width] = L'\0';
-    }
-
         return width;
+    }
 }
 
 static void line_info_init_line(ToxWindow *self, struct line_info *line)

src/message_queue.c

@@ -48,7 +48,7 @@ void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type,
         return;
     }
 
-    struct cqueue_msg *new_m = malloc(sizeof(struct cqueue_msg));
+    struct cqueue_msg *new_m = calloc(1, sizeof(struct cqueue_msg));
 
     if (new_m == NULL) {
         exit_toxic_err("failed in cqueue_message", FATALERR_MEMORY);
@@ -62,6 +62,7 @@ void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type,
     new_m->time_added = get_unix_time();
     new_m->receipt = -1;
     new_m->next = NULL;
+    new_m->noread_flag = false;
 
     if (q->root == NULL) {
         new_m->prev = NULL;
@@ -203,7 +204,7 @@ void cqueue_try_send(ToxWindow *self, Tox *m)
             return;
         }
 
-        TOX_ERR_FRIEND_SEND_MESSAGE err;
+        Tox_Err_Friend_Send_Message err;
         Tox_Message_Type type = msg->type == OUT_MSG ? TOX_MESSAGE_TYPE_NORMAL : TOX_MESSAGE_TYPE_ACTION;
         uint32_t receipt = tox_friend_send_message(m, self->num, type, (uint8_t *) msg->message, msg->len, &err);
 

src/misc_tools.c

@@ -477,10 +477,9 @@ on_error:
    returns length of msg, which will be no larger than size-1 */
 size_t copy_tox_str(char *msg, size_t size, const char *data, size_t length)
 {
-    size_t i;
     size_t j = 0;
 
-    for (i = 0; (i < length) && (j < size - 1); ++i) {
+    for (size_t i = 0; (i < length) && (j < size - 1); ++i) {
         if (data[i] != '\r') {
             msg[j++] = data[i];
         }

src/netprof.c

@@ -0,0 +1,299 @@
+/*  netprof.c
+ *
+ *
+ *  Copyright (C) 2022 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "netprof.h"
+
+#include "../../toxcore/toxcore/tox_private.h"  // set this to your local toxcore source directory
+
+static void log_tcp_packet_id(FILE *fp, unsigned int id, uint64_t total, uint64_t TCP_id_sent, uint64_t TCP_id_recv)
+{
+    switch (id) {
+        case TOX_NETPROF_PACKET_ID_ZERO:
+        case TOX_NETPROF_PACKET_ID_ONE:
+        case TOX_NETPROF_PACKET_ID_TWO:
+        case TOX_NETPROF_PACKET_ID_TCP_DISCONNECT:
+        case TOX_NETPROF_PACKET_ID_FOUR:
+        case TOX_NETPROF_PACKET_ID_TCP_PONG:
+        case TOX_NETPROF_PACKET_ID_TCP_OOB_SEND:
+        case TOX_NETPROF_PACKET_ID_TCP_OOB_RECV:
+        case TOX_NETPROF_PACKET_ID_TCP_ONION_REQUEST:
+        case TOX_NETPROF_PACKET_ID_TCP_ONION_RESPONSE:
+        case TOX_NETPROF_PACKET_ID_TCP_DATA: {
+            if (TCP_id_recv || TCP_id_sent) {
+                fprintf(fp, "0x%02x (total):     %lu (%.2f%%)\n", id, TCP_id_sent + TCP_id_recv,
+                        ((float)TCP_id_recv + TCP_id_sent) / total * 100.0);
+            }
+
+            if (TCP_id_sent) {
+                fprintf(fp, "0x%02x (sent):      %lu (%.2f%%)\n", id, TCP_id_sent, (float)TCP_id_sent / total * 100.0);
+            }
+
+            if (TCP_id_recv) {
+                fprintf(fp, "0x%02x (recv):      %lu (%.2f%%)\n", id, TCP_id_recv, (float)TCP_id_recv / total * 100.0);
+            }
+
+            break;
+        }
+
+        default:
+            return;
+    }
+}
+static void log_udp_packet_id(FILE *fp, unsigned int id, uint64_t total, uint64_t UDP_id_sent, uint64_t UDP_id_recv)
+{
+    switch (id) {
+        case TOX_NETPROF_PACKET_ID_ZERO:
+        case TOX_NETPROF_PACKET_ID_ONE:
+        case TOX_NETPROF_PACKET_ID_TWO:
+        case TOX_NETPROF_PACKET_ID_FOUR:
+        case TOX_NETPROF_PACKET_ID_COOKIE_REQUEST:
+        case TOX_NETPROF_PACKET_ID_COOKIE_RESPONSE:
+        case TOX_NETPROF_PACKET_ID_CRYPTO_HS:
+        case TOX_NETPROF_PACKET_ID_CRYPTO_DATA:
+        case TOX_NETPROF_PACKET_ID_CRYPTO:
+        case TOX_NETPROF_PACKET_ID_LAN_DISCOVERY:
+        case TOX_NETPROF_PACKET_ID_ONION_SEND_INITIAL:
+        case TOX_NETPROF_PACKET_ID_ONION_SEND_1:
+        case TOX_NETPROF_PACKET_ID_ONION_SEND_2:
+        case TOX_NETPROF_PACKET_ID_ANNOUNCE_REQUEST:
+        case TOX_NETPROF_PACKET_ID_ANNOUNCE_RESPONSE:
+        case TOX_NETPROF_PACKET_ID_ONION_DATA_REQUEST:
+        case TOX_NETPROF_PACKET_ID_ONION_DATA_RESPONSE:
+        case TOX_NETPROF_PACKET_ID_ONION_RECV_3:
+        case TOX_NETPROF_PACKET_ID_ONION_RECV_2:
+        case TOX_NETPROF_PACKET_ID_ONION_RECV_1:
+        case TOX_NETPROF_PACKET_ID_BOOTSTRAP_INFO: {
+            if (UDP_id_recv || UDP_id_sent) {
+                fprintf(fp, "0x%02x (total):     %lu (%.2f%%)\n", id, UDP_id_sent + UDP_id_recv,
+                        ((float)UDP_id_recv + UDP_id_sent) / total * 100.0);
+            }
+
+            if (UDP_id_sent) {
+                fprintf(fp, "0x%02x (sent):      %lu (%.2f%%)\n", id, UDP_id_sent, (float)UDP_id_sent / total * 100.0);
+            }
+
+            if (UDP_id_recv) {
+                fprintf(fp, "0x%02x (recv):      %lu (%.2f%%)\n", id, UDP_id_recv, (float)UDP_id_recv / total * 100.0);
+            }
+
+            break;
+        }
+
+        default:
+            return;
+    }
+}
+
+static void dump_packet_id_counts(const Tox *m, FILE *fp, uint64_t total_count, Tox_Netprof_Packet_Type packet_type)
+{
+    if (packet_type == TOX_NETPROF_PACKET_TYPE_TCP) {
+        fprintf(fp, "--- TCP packet counts by packet ID --- \n");
+    } else {
+        fprintf(fp, "--- UDP packet counts by packet ID --- \n");
+    }
+
+    for (unsigned long i = TOX_NETPROF_PACKET_ID_ZERO; i <= TOX_NETPROF_PACKET_ID_BOOTSTRAP_INFO; ++i) {
+        const uint64_t id_count_sent = tox_netprof_get_packet_id_count(m, packet_type, i, TOX_NETPROF_DIRECTION_SENT);
+        const uint64_t id_count_recv = tox_netprof_get_packet_id_count(m, packet_type, i, TOX_NETPROF_DIRECTION_RECV);
+
+        if (packet_type == TOX_NETPROF_PACKET_TYPE_TCP) {
+            log_tcp_packet_id(fp, i, total_count, id_count_sent, id_count_recv);
+        } else {
+            log_udp_packet_id(fp, i, total_count, id_count_sent, id_count_recv);
+        }
+    }
+
+    fprintf(fp, "\n\n");
+}
+
+static void dump_packet_id_bytes(const Tox *m, FILE *fp, uint64_t total_bytes, Tox_Netprof_Packet_Type packet_type)
+{
+    if (packet_type == TOX_NETPROF_PACKET_TYPE_TCP) {
+        fprintf(fp, "--- TCP byte counts by packet ID --- \n");
+    } else {
+        fprintf(fp, "--- UDP byte counts by packet ID --- \n");
+    }
+
+    for (unsigned long i = TOX_NETPROF_PACKET_ID_ZERO; i <= TOX_NETPROF_PACKET_ID_BOOTSTRAP_INFO; ++i) {
+        const uint64_t id_bytes_sent = tox_netprof_get_packet_id_bytes(m, packet_type, i, TOX_NETPROF_DIRECTION_SENT);
+        const uint64_t id_bytes_recv = tox_netprof_get_packet_id_bytes(m, packet_type, i, TOX_NETPROF_DIRECTION_RECV);
+
+        if (packet_type == TOX_NETPROF_PACKET_TYPE_TCP) {
+            log_tcp_packet_id(fp, i, total_bytes, id_bytes_sent, id_bytes_recv);
+        } else {
+            log_udp_packet_id(fp, i, total_bytes, id_bytes_sent, id_bytes_recv);
+        }
+    }
+
+    fprintf(fp, "\n\n");
+}
+
+static void dump_packet_count_totals(const Tox *m, FILE *fp, uint64_t total_packet_count,
+                                     uint64_t UDP_count_sent, uint64_t UDP_count_recv,
+                                     uint64_t TCP_count_sent, uint64_t TCP_count_recv)
+{
+    const uint64_t total_UDP_count = UDP_count_sent + UDP_count_recv;
+    const uint64_t total_TCP_count = TCP_count_sent + TCP_count_recv;
+    const uint64_t total_packet_count_sent = UDP_count_sent + TCP_count_sent;
+    const uint64_t total_packet_count_recv = UDP_count_recv + TCP_count_recv;
+
+    fprintf(fp, "--- Total packet counts --- \n");
+
+    fprintf(fp, "Total packets:          %lu\n", total_packet_count);
+
+    fprintf(fp, "Total packets sent:     %lu (%.2f%%)\n", total_packet_count_sent,
+            (float)total_packet_count_sent / total_packet_count * 100.0);
+
+    fprintf(fp, "Total packets recv:     %lu (%.2f%%)\n", total_packet_count_recv,
+            (float)total_packet_count_recv / total_packet_count * 100.0);
+
+    fprintf(fp, "total UDP packets:      %lu (%.2f%%)\n", total_UDP_count,
+            (float)total_UDP_count / total_packet_count * 100.0);
+
+    fprintf(fp, "UDP packets sent:       %lu (%.2f%%)\n", UDP_count_sent,
+            (float)UDP_count_sent / total_packet_count * 100.0);
+
+    fprintf(fp, "UDP packets recv:       %lu (%.2f%%)\n", UDP_count_recv,
+            (float)UDP_count_recv / total_packet_count * 100.0);
+
+    fprintf(fp, "Total TCP packets:      %lu (%.2f%%)\n", total_TCP_count,
+            (float)total_TCP_count / total_packet_count * 100.0);
+
+    fprintf(fp, "TCP packets sent:       %lu (%.2f%%)\n", TCP_count_sent,
+            (float)TCP_count_sent / total_packet_count * 100.0);
+
+    fprintf(fp, "TCP packets recv:       %lu (%.2f%%)\n", TCP_count_recv,
+            (float)TCP_count_recv / total_packet_count * 100.0);
+
+    fprintf(fp, "\n\n");
+}
+
+void dump_packet_bytes_totals(const Tox *m, FILE *fp, const uint64_t total_bytes,
+                              const uint64_t UDP_bytes_sent, const uint64_t UDP_bytes_recv,
+                              const uint64_t TCP_bytes_sent, const uint64_t TCP_bytes_recv)
+{
+    const uint64_t total_UDP_bytes = UDP_bytes_sent + UDP_bytes_recv;
+    const uint64_t total_TCP_bytes = TCP_bytes_sent + TCP_bytes_recv;
+    const uint64_t total_bytes_sent = UDP_bytes_sent + TCP_bytes_sent;
+    const uint64_t total_bytes_recv = UDP_bytes_recv + TCP_bytes_recv;
+
+    fprintf(fp, "--- Total byte counts --- \n");
+
+    fprintf(fp, "Total bytes:            %lu\n", total_bytes);
+
+    fprintf(fp, "Total bytes sent:       %lu (%.2f%%)\n", total_bytes_sent,
+            (float)total_bytes_sent / total_bytes * 100.0);
+
+    fprintf(fp, "Total bytes recv:       %lu (%.2f%%)\n", total_bytes_recv,
+            (float)total_bytes_recv / total_bytes * 100.0);
+
+    fprintf(fp, "Total UDP bytes:        %lu (%.2f%%)\n", total_UDP_bytes,
+            (float)total_UDP_bytes / total_bytes * 100.0);
+
+    fprintf(fp, "UDP bytes sent:         %lu (%.2f%%)\n", UDP_bytes_sent,
+            (float)UDP_bytes_sent / total_bytes * 100.0);
+
+    fprintf(fp, "UDP bytes recv:         %lu (%.2f%%)\n", UDP_bytes_recv,
+            (float)UDP_bytes_recv / total_bytes * 100.0);
+
+    fprintf(fp, "Total TCP bytes:        %lu (%.2f%%)\n", total_TCP_bytes,
+            (float)total_TCP_bytes / total_bytes * 100.0);
+
+    fprintf(fp, "TCP bytes sent:         %lu (%.2f%%)\n", TCP_bytes_sent,
+            (float)TCP_bytes_sent / total_bytes * 100.0);
+
+    fprintf(fp, "TCP bytes recv:         %lu (%.2f%%)\n", TCP_bytes_recv,
+            (float)TCP_bytes_recv / total_bytes * 100.0);
+
+    fprintf(fp, "\n\n");
+}
+
+void netprof_log_dump(const Tox *m, FILE *fp, time_t run_time)
+{
+    if (fp == NULL) {
+        fprintf(stderr, "Failed to dump network statistics: null file pointer\n");
+        return;
+    }
+
+    const uint64_t UDP_count_sent = tox_netprof_get_packet_total_count(m, TOX_NETPROF_PACKET_TYPE_UDP,
+                                    TOX_NETPROF_DIRECTION_SENT);
+    const uint64_t UDP_count_recv = tox_netprof_get_packet_total_count(m, TOX_NETPROF_PACKET_TYPE_UDP,
+                                    TOX_NETPROF_DIRECTION_RECV);
+    const uint64_t TCP_count_sent = tox_netprof_get_packet_total_count(m, TOX_NETPROF_PACKET_TYPE_TCP,
+                                    TOX_NETPROF_DIRECTION_SENT);
+    const uint64_t TCP_count_recv = tox_netprof_get_packet_total_count(m, TOX_NETPROF_PACKET_TYPE_TCP,
+                                    TOX_NETPROF_DIRECTION_RECV);
+    const uint64_t UDP_bytes_sent = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_UDP,
+                                    TOX_NETPROF_DIRECTION_SENT);
+    const uint64_t UDP_bytes_recv = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_UDP,
+                                    TOX_NETPROF_DIRECTION_RECV);
+    const uint64_t TCP_bytes_sent = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_TCP,
+                                    TOX_NETPROF_DIRECTION_SENT);
+    const uint64_t TCP_bytes_recv = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_TCP,
+                                    TOX_NETPROF_DIRECTION_RECV);
+
+    const uint64_t total_count = UDP_count_sent + UDP_count_recv + TCP_count_sent + TCP_count_recv;
+    const uint64_t total_bytes = UDP_bytes_sent + UDP_bytes_recv + TCP_bytes_sent + TCP_bytes_recv;
+
+    fprintf(fp, "--- Tox network profile log dump ---\n");
+    fprintf(fp, "Run time: %lu seconds\n", run_time);
+
+    if (run_time && total_count && total_bytes) {
+        fprintf(fp, "Average kilobytes per second: %.2f\n", ((float)total_bytes / run_time) / 1000.0);
+        fprintf(fp, "Average packets per second: %lu\n", total_count / run_time);
+        fprintf(fp, "Average packet size: %lu bytes\n", total_bytes / total_count);
+        fprintf(fp, "\n");
+    }
+
+    dump_packet_count_totals(m, fp, total_count, UDP_count_sent, UDP_count_recv, TCP_count_sent, TCP_count_recv);
+    dump_packet_bytes_totals(m, fp, total_bytes, UDP_bytes_sent, UDP_bytes_recv, TCP_bytes_sent, TCP_bytes_recv);
+    dump_packet_id_counts(m, fp, total_count, TOX_NETPROF_PACKET_TYPE_TCP);
+    dump_packet_id_counts(m, fp, total_count, TOX_NETPROF_PACKET_TYPE_UDP);
+    dump_packet_id_bytes(m, fp, total_bytes, TOX_NETPROF_PACKET_TYPE_TCP);
+    dump_packet_id_bytes(m, fp, total_bytes, TOX_NETPROF_PACKET_TYPE_UDP);
+
+    fflush(fp);
+}
+
+uint64_t netprof_get_bytes_up(const Tox *m)
+{
+    const uint64_t UDP_bytes_sent = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_UDP,
+                                    TOX_NETPROF_DIRECTION_SENT);
+    const uint64_t TCP_bytes_sent = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_TCP,
+                                    TOX_NETPROF_DIRECTION_SENT);
+
+    return UDP_bytes_sent + TCP_bytes_sent;
+
+}
+
+uint64_t netprof_get_bytes_down(const Tox *m)
+{
+    const uint64_t UDP_bytes_recv = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_UDP,
+                                    TOX_NETPROF_DIRECTION_RECV);
+    const uint64_t TCP_bytes_recv = tox_netprof_get_packet_total_bytes(m, TOX_NETPROF_PACKET_TYPE_TCP,
+                                    TOX_NETPROF_DIRECTION_RECV);
+
+    return UDP_bytes_recv + TCP_bytes_recv;
+}

src/netprof.h

@@ -0,0 +1,35 @@
+/*  netprof.h
+ *
+ *
+ *  Copyright (C) 2022 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TOXIC_NETPROF
+#define TOXIC_NETPROF
+
+#include <stdio.h>
+#include <time.h>
+#include <tox/tox.h>
+
+void netprof_log_dump(const Tox *m, FILE *fp, time_t run_time);
+
+uint64_t netprof_get_bytes_down(const Tox *m);
+uint64_t netprof_get_bytes_up(const Tox *m);
+
+#endif  // TOXIC_NETPROF

src/prompt.c

@@ -36,6 +36,7 @@
 #include "line_info.h"
 #include "log.h"
 #include "misc_tools.h"
+#include "netprof.h"
 #include "notify.h"
 #include "prompt.h"
 #include "settings.h"
@@ -305,6 +306,77 @@ static bool prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     return input_ret;
 }
 
+#define NET_INFO_REFRESH_INTERVAL 1
+static void draw_network_info(const Tox *m, StatusBar *stb)
+{
+    WINDOW *win = stb->topline;
+
+    wattron(win, COLOR_PAIR(BAR_TEXT));
+    wprintw(win, "%s", stb->network_info);
+    wattroff(win, COLOR_PAIR(BAR_TEXT));
+
+    if (!timed_out(stb->time_last_refreshed, NET_INFO_REFRESH_INTERVAL)) {
+        return;
+    }
+
+    stb->time_last_refreshed = get_unix_time();
+
+    const uint64_t up_bytes = netprof_get_bytes_up(m);
+    const uint64_t down_bytes = netprof_get_bytes_down(m);
+
+    const uint64_t up_delta = (up_bytes - stb->up_bytes) / NET_INFO_REFRESH_INTERVAL;
+    const uint64_t down_delta = (down_bytes - stb->down_bytes) / NET_INFO_REFRESH_INTERVAL;
+
+    stb->up_bytes = up_bytes;
+    stb->down_bytes = down_bytes;
+
+    float up = up_bytes;
+    float down = down_bytes;
+    const char *up_unit = "bytes";
+    const char *down_unit = "bytes";
+
+    if (up_bytes > MiB) {
+        up /= (float)MiB;
+        up_unit = "MiB";
+    } else if (up_bytes > KiB) {
+        up /= (float)KiB;
+        up_unit = "KiB";
+    }
+
+    if (down_bytes > MiB) {
+        down /= (float)MiB;
+        down_unit = "MiB";
+    } else if (down_bytes > KiB) {
+        down /= (float)KiB;
+        down_unit = "KiB";
+    }
+
+    float up_bps = up_delta;
+    float down_bps = down_delta;
+    const char *up_bps_unit = "b/s";
+    const char *down_bps_unit = "b/s";
+
+    if (up_bps > MiB) {
+        up_bps /= (float)MiB;
+        up_bps_unit = "MiB/s";
+    } else if (up_bps > KiB) {
+        up_bps /= (float)KiB;
+        up_bps_unit = "KiB/s";
+    }
+
+    if (down_bps > MiB) {
+        down_bps /= (float)MiB;
+        down_bps_unit = "MiB/s";
+    } else if (down_bps > KiB) {
+        down_bps /= (float)KiB;
+        down_bps_unit = "KiB/s";
+    }
+
+    snprintf(stb->network_info, sizeof(stb->network_info),
+             " | [Up: %.1f%s (%.1f%s) | Down: %.1f%s (%.1f%s)]", up, up_unit, up_bps, up_bps_unit,
+             down, down_unit, down_bps, down_bps_unit);
+}
+
 static void prompt_onDraw(ToxWindow *self, Tox *m)
 {
     int x2;
@@ -462,6 +534,10 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
         wattroff(statusbar->topline, COLOR_PAIR(BAR_TEXT));
     }
 
+    if (user_settings->show_network_info) {
+        draw_network_info(m, statusbar);
+    }
+
     int y;
     int x;
     getyx(self->window, y, x);

src/python_api.c

@@ -20,9 +20,10 @@
  *
  */
 
+#include "api.h"
+
 #ifdef PYTHON
 #include <Python.h>
-#include "api.h"
 
 #include "execute.h"
 

src/settings.c

@@ -63,6 +63,7 @@ static struct ui_strings {
     const char *show_typing_other;
     const char *show_welcome_msg;
     const char *show_connection_msg;
+    const char *show_network_info;
     const char *nodeslist_update_freq;
     const char *autosave_freq;
 
@@ -97,6 +98,7 @@ static struct ui_strings {
     "show_typing_other",
     "show_welcome_msg",
     "show_connection_msg",
+    "show_network_info",
     "nodeslist_update_freq",
     "autosave_freq",
     "line_join",
@@ -130,6 +132,7 @@ static void ui_defaults(struct user_settings *settings)
     settings->show_typing_other = SHOW_TYPING_ON;
     settings->show_welcome_msg = SHOW_WELCOME_MSG_ON;
     settings->show_connection_msg = SHOW_CONNECTION_MSG_ON;
+    settings->show_network_info = SHOW_NETWORK_INFO_OFF;
     settings->nodeslist_update_freq = 7;
     settings->autosave_freq = 600;
 
@@ -398,6 +401,7 @@ int settings_load(struct user_settings *s, const char *patharg)
         config_setting_lookup_bool(setting, ui_strings.show_typing_other, &s->show_typing_other);
         config_setting_lookup_bool(setting, ui_strings.show_welcome_msg, &s->show_welcome_msg);
         config_setting_lookup_bool(setting, ui_strings.show_connection_msg, &s->show_connection_msg);
+        config_setting_lookup_bool(setting, ui_strings.show_network_info, &s->show_network_info);
 
         config_setting_lookup_int(setting, ui_strings.history_size, &s->history_size);
         config_setting_lookup_int(setting, ui_strings.notification_timeout, &s->notification_timeout);

src/settings.h

@@ -54,6 +54,7 @@ struct user_settings {
     int show_typing_other; /* boolean */
     int show_welcome_msg;  /* boolean */
     int show_connection_msg;  /* boolean */
+    int show_network_info; /* boolean */
     int nodeslist_update_freq;  /* int (<= 0 to disable updates) */
     int autosave_freq; /* int (<= 0 to disable autosave) */
 
@@ -120,6 +121,9 @@ enum settings_values {
     SHOW_CONNECTION_MSG_OFF = 0,
     SHOW_CONNECTION_MSG_ON = 1,
 
+    SHOW_NETWORK_INFO_OFF = 0,
+    SHOW_NETWORK_INFO_ON = 1,
+
     DFLT_HST_SIZE = 700,
 
     MPLEX_OFF = 0,

src/toxic.c

@@ -58,6 +58,7 @@
 #include "message_queue.h"
 #include "misc_tools.h"
 #include "name_lookup.h"
+#include "netprof.h"
 #include "notify.h"
 #include "prompt.h"
 #include "settings.h"
@@ -143,6 +144,22 @@ static void catch_SIGSEGV(int sig)
     exit(EXIT_FAILURE);
 }
 
+void cb_toxcore_logger(Tox *m, TOX_LOG_LEVEL level, const char *file, uint32_t line, const char *func,
+                       const char *message, void *user_data)
+{
+    UNUSED_VAR(user_data);
+    UNUSED_VAR(file);
+    UNUSED_VAR(m);
+
+    if (user_data) {
+        FILE *fp = (FILE *)user_data;
+        fprintf(fp, "[%d] %u:%s() - %s\n", level, line, func, message);
+        fflush(fp);
+    } else {
+        fprintf(stderr, "[%d] %u:%s() - %s\n", level, line, func, message);
+    }
+}
+
 static void flag_window_resize(int sig)
 {
     UNUSED_VAR(sig);
@@ -177,6 +194,10 @@ void free_global_data(void)
 
 void exit_toxic_success(Tox *m)
 {
+    if (arg_opts.netprof_log_dump) {
+        netprof_log_dump(m, arg_opts.netprof_fp, get_unix_time() - arg_opts.netprof_start_time);
+    }
+
     store_data(m, DATA_FILE);
 
     user_password = (struct user_password) {
@@ -207,6 +228,11 @@ void exit_toxic_success(Tox *m)
         arg_opts.log_fp = NULL;
     }
 
+    if (arg_opts.netprof_fp != NULL) {
+        fclose(arg_opts.netprof_fp);
+        arg_opts.netprof_fp = NULL;
+    }
+
     endwin();
     curl_global_cleanup();
 
@@ -229,22 +255,6 @@ void exit_toxic_err(const char *errmsg, int errcode)
     exit(EXIT_FAILURE);
 }
 
-void cb_toxcore_logger(Tox *m, TOX_LOG_LEVEL level, const char *file, uint32_t line, const char *func,
-                       const char *message, void *user_data)
-{
-    UNUSED_VAR(user_data);
-    UNUSED_VAR(file);
-    UNUSED_VAR(m);
-
-    if (user_data) {
-        FILE *fp = (FILE *)user_data;
-        fprintf(fp, "[%d] %u:%s() - %s\n", level, line, func, message);
-        fflush(fp);
-    } else {
-        fprintf(stderr, "[%d] %u:%s() - %s\n", level, line, func, message);
-    }
-}
-
 /* Sets ncurses refresh rate. Lower values make it refresh more often. */
 void set_window_refresh_rate(size_t refresh_rate)
 {
@@ -1199,6 +1209,7 @@ static void print_usage(void)
     fprintf(stderr, "  -p, --SOCKS5-proxy       Use SOCKS5 proxy: Requires [IP] [port]\n");
     fprintf(stderr, "  -P, --HTTP-proxy         Use HTTP proxy: Requires [IP] [port]\n");
     fprintf(stderr, "  -r, --namelist           Use specified name lookup server list\n");
+    fprintf(stderr, "  -s, --netstats           Dump network statistic to log on exit: Requires [path]\n");
     fprintf(stderr, "  -t, --force-tcp          Force toxic to use a TCP connection (use with proxies)\n");
     fprintf(stderr, "  -T, --tcp-server         Act as a TCP relay server: Requires [port]\n");
     fprintf(stderr, "  -u, --unencrypt-data     Unencrypt an encrypted data file\n");
@@ -1238,6 +1249,7 @@ static void parse_args(int argc, char *argv[])
         {"help", no_argument, 0, 'h'},
         {"noconnect", no_argument, 0, 'o'},
         {"namelist", required_argument, 0, 'r'},
+        {"netstats", required_argument, 0, 's'},
         {"force-tcp", no_argument, 0, 't'},
         {"tcp-server", required_argument, 0, 'T'},
         {"SOCKS5-proxy", required_argument, 0, 'p'},
@@ -1247,7 +1259,7 @@ static void parse_args(int argc, char *argv[])
         {NULL, no_argument, NULL, 0},
     };
 
-    const char *opts_str = "4bdehLotuxvc:f:l:n:r:p:P:T:";
+    const char *opts_str = "4bdehLotuxvc:f:l:n:r:s:p:P:T:";
     int opt = 0;
     int indexptr = 0;
 
@@ -1443,6 +1455,25 @@ static void parse_args(int argc, char *argv[])
                 break;
             }
 
+            case 's': {
+                if (optarg == NULL) {
+                    queue_init_message("Invalid argument for option: %d", opt);
+                    break;
+                }
+
+                arg_opts.netprof_fp = fopen(optarg, "w");
+
+                if (arg_opts.netprof_fp != NULL) {
+                    queue_init_message("Network profile logging enabled. Logging to file: '%s'", optarg);
+                    arg_opts.netprof_log_dump = true;
+                    arg_opts.netprof_start_time = time(NULL);
+                } else {
+                    queue_init_message("Failed to open file '%s' for network profile logging.", optarg);
+                }
+
+                break;
+            }
+
             case 'u': {
                 arg_opts.unencrypt_data = 1;
                 break;

src/windows.h

@@ -142,6 +142,10 @@ struct arg_opts {
     bool logging;
     FILE *log_fp;
 
+    bool   netprof_log_dump;
+    time_t netprof_start_time;
+    FILE   *netprof_fp;
+
     char proxy_address[256];
     uint8_t proxy_type;
     uint16_t proxy_port;
@@ -248,6 +252,12 @@ struct StatusBar {
     size_t nick_len;
     Tox_User_Status status;
     Tox_Connection connection;
+
+    /* network info */
+    uint64_t up_bytes;
+    uint64_t down_bytes;
+    uint64_t time_last_refreshed;
+    char network_info[MAX_STR_SIZE];
 };
 
 #ifdef AUDIO