feat: add message IDs to private group packets

JFreegman · JFreegman · commit 0a932638a1f9 · 2024-03-07T09:45:25.000-05:00
diff --git a/auto_tests/group_message_test.c b/auto_tests/group_message_test.c
@@ -274,7 +274,6 @@ static void group_message_handler(const Tox_Event_Group_Message *event, void *us
     State *state = (State *)autotox->state;
 
     state->message_received = true;
-
     state->pseudo_msg_id = pseudo_msg_id;
 }
 
@@ -288,6 +287,7 @@ static void group_private_message_handler(const Tox_Event_Group_Private_Message
     const Tox_Message_Type type = tox_event_group_private_message_get_type(event);
     const uint8_t *message = tox_event_group_private_message_get_message(event);
     const size_t length = tox_event_group_private_message_get_message_length(event);
+    const uint32_t pseudo_msg_id = tox_event_group_private_message_get_message_id(event);
 
     ck_assert_msg(length == TEST_PRIVATE_MESSAGE_LEN, "Failed to receive message. Invalid length: %zu\n", length);
 
@@ -320,14 +320,15 @@ static void group_private_message_handler(const Tox_Event_Group_Private_Message
     ck_assert(s_err == TOX_ERR_GROUP_SELF_QUERY_OK);
     ck_assert(memcmp(self_name, PEER1_NICK, self_name_len) == 0);
 
-    printf("%s sent private action to %s: %s\n", peer_name, self_name, message_buf);
+    printf("%s sent private action to %s:(id: %u) %s\n", peer_name, self_name, pseudo_msg_id, message_buf);
     ck_assert(memcmp(message_buf, TEST_PRIVATE_MESSAGE, length) == 0);
 
     ck_assert(type == TOX_MESSAGE_TYPE_ACTION);
 
     State *state = (State *)autotox->state;
 
     state->private_message_received = true;
+    state->pseudo_msg_id = pseudo_msg_id;
 }
 
 static void group_message_handler_lossless_test(const Tox_Event_Group_Message *event, void *user_data)
@@ -435,7 +436,8 @@ static void group_message_test(AutoTox *autotoxes)
         }
     }
 
-    ck_assert_msg(state0->pseudo_msg_id == state1->pseudo_msg_id, "id0:%u id1:%u", state0->pseudo_msg_id, state1->pseudo_msg_id);
+    ck_assert_msg(state0->pseudo_msg_id == state1->pseudo_msg_id, "id0:%u id1:%u",
+                  state0->pseudo_msg_id, state1->pseudo_msg_id);
 
     // Make sure we're still connected to each friend
     Tox_Connection conn_1 = tox_friend_get_connection_status(tox0, 0, nullptr);
@@ -460,14 +462,23 @@ static void group_message_test(AutoTox *autotoxes)
     tox_group_set_ignore(tox0, group_number, state0->peer_id, false, &ig_err);
     ck_assert_msg(ig_err == TOX_ERR_GROUP_SET_IGNORE_OK, "%d", ig_err);
 
-    fprintf(stderr, "Sending private message...\n");
+    fprintf(stderr, "Sending private action...\n");
 
-    // tox0 sends a private action to tox1
+    // tox1 sends a private action to tox0
     Tox_Err_Group_Send_Private_Message m_err;
-    tox_group_send_private_message(tox1, group_number, state1->peer_id, TOX_MESSAGE_TYPE_ACTION,
-                                   (const uint8_t *)TEST_PRIVATE_MESSAGE, TEST_PRIVATE_MESSAGE_LEN, &m_err);
+    state1->pseudo_msg_id = tox_group_send_private_message(tox1, group_number, state1->peer_id,
+                            TOX_MESSAGE_TYPE_ACTION, (const uint8_t *)TEST_PRIVATE_MESSAGE,
+                            TEST_PRIVATE_MESSAGE_LEN, &m_err);
+
     ck_assert_msg(m_err == TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK, "%d", m_err);
 
+    while (!state0->private_message_received) {
+        iterate_all_wait(autotoxes, NUM_GROUP_TOXES, ITERATION_INTERVAL);
+    }
+
+    ck_assert_msg(state0->pseudo_msg_id == state1->pseudo_msg_id, "id0:%u id1:%u",
+                  state0->pseudo_msg_id, state1->pseudo_msg_id);
+
     fprintf(stderr, "Sending custom packets...\n");
 
     // tox0 sends a lossless and lossy custom packet to tox1
@@ -496,8 +507,7 @@ static void group_message_test(AutoTox *autotoxes)
 
     ck_assert_msg(cperr == TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK, "%d", cperr);
 
-    while (!state0->private_message_received || state0->custom_packets_received < 2
-            || state0->custom_private_packets_received < 2) {
+    while (state0->custom_packets_received < 2 || state0->custom_private_packets_received < 2) {
         iterate_all_wait(autotoxes, NUM_GROUP_TOXES, ITERATION_INTERVAL);
     }
 
diff --git a/other/event_tooling/generate_event_c.cpp b/other/event_tooling/generate_event_c.cpp
@@ -757,6 +757,7 @@ int main(int argc, char** argv) {
                 EventTypeTrivial{"uint32_t", "peer_id"},
                 EventTypeTrivial{"Tox_Message_Type", "type"},
                 EventTypeByteRange{"message", "message_length", "length"}, // the latter two are ideally the same
+                EventTypeTrivial{"uint32_t", "message_id"},
             }
         },
         {
diff --git a/toxcore/events/group_private_message.c b/toxcore/events/group_private_message.c
@@ -30,6 +30,7 @@ struct Tox_Event_Group_Private_Message {
     Tox_Message_Type type;
     uint8_t *message;
     uint32_t message_length;
+    uint32_t message_id;
 };
 
 non_null()
@@ -110,6 +111,19 @@ const uint8_t *tox_event_group_private_message_get_message(const Tox_Event_Group
     return group_private_message->message;
 }
 
+non_null()
+static void tox_event_group_private_message_set_message_id(Tox_Event_Group_Private_Message *group_private_message,
+        uint32_t message_id)
+{
+    assert(group_private_message != nullptr);
+    group_private_message->message_id = message_id;
+}
+uint32_t tox_event_group_private_message_get_message_id(const Tox_Event_Group_Private_Message *group_private_message)
+{
+    assert(group_private_message != nullptr);
+    return group_private_message->message_id;
+}
+
 non_null()
 static void tox_event_group_private_message_construct(Tox_Event_Group_Private_Message *group_private_message)
 {
@@ -126,26 +140,28 @@ static void tox_event_group_private_message_destruct(Tox_Event_Group_Private_Mes
 bool tox_event_group_private_message_pack(
     const Tox_Event_Group_Private_Message *event, Bin_Pack *bp)
 {
-    return bin_pack_array(bp, 4)
+    return bin_pack_array(bp, 5)
            && bin_pack_u32(bp, event->group_number)
            && bin_pack_u32(bp, event->peer_id)
            && tox_message_type_pack(event->type, bp)
-           && bin_pack_bin(bp, event->message, event->message_length);
+           && bin_pack_bin(bp, event->message, event->message_length)
+           && bin_pack_u32(bp, event->message_id);
 }
 
 non_null()
 static bool tox_event_group_private_message_unpack_into(
     Tox_Event_Group_Private_Message *event, Bin_Unpack *bu)
 {
     assert(event != nullptr);
-    if (!bin_unpack_array_fixed(bu, 4, nullptr)) {
+    if (!bin_unpack_array_fixed(bu, 5, nullptr)) {
         return false;
     }
 
     return bin_unpack_u32(bu, &event->group_number)
            && bin_unpack_u32(bu, &event->peer_id)
            && tox_message_type_unpack(&event->type, bu)
-           && bin_unpack_bin(bu, &event->message, &event->message_length);
+           && bin_unpack_bin(bu, &event->message, &event->message_length)
+           && bin_unpack_u32(bu, &event->message_id);
 }
 
 /*****************************************************
@@ -238,7 +254,7 @@ static Tox_Event_Group_Private_Message *tox_event_group_private_message_alloc(vo
  *****************************************************/
 
 void tox_events_handle_group_private_message(
-    Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, const uint8_t *message, size_t length,
+    Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, const uint8_t *message, size_t length, uint32_t message_id,
     void *user_data)
 {
     Tox_Event_Group_Private_Message *group_private_message = tox_event_group_private_message_alloc(user_data);
@@ -251,4 +267,5 @@ void tox_events_handle_group_private_message(
     tox_event_group_private_message_set_peer_id(group_private_message, peer_id);
     tox_event_group_private_message_set_type(group_private_message, type);
     tox_event_group_private_message_set_message(group_private_message, message, length);
+    tox_event_group_private_message_set_message_id(group_private_message, message_id);
 }
diff --git a/toxcore/group_chats.c b/toxcore/group_chats.c
@@ -4911,11 +4911,12 @@ int gc_send_message(const GC_Chat *chat, const uint8_t *message, uint16_t length
         return -5;
     }
 
+    free(message_raw);
+
     if (message_id != nullptr) {
         *message_id = pseudo_msg_id;
     }
 
-    free(message_raw);
     return 0;
 }
 
@@ -4955,7 +4956,7 @@ static int handle_gc_message(const GC_Session *c, const GC_Chat *chat, const GC_
 }
 
 int gc_send_private_message(const GC_Chat *chat, GC_Peer_Id peer_id, uint8_t type, const uint8_t *message,
-                            uint16_t length)
+                            uint16_t length, uint32_t *message_id)
 {
     if (length > MAX_GC_MESSAGE_SIZE) {
         return -1;
@@ -4981,23 +4982,28 @@ int gc_send_private_message(const GC_Chat *chat, GC_Peer_Id peer_id, uint8_t typ
         return -5;
     }
 
-    uint8_t *message_with_type = (uint8_t *)malloc(length + 1);
+    const uint16_t raw_length = 1 + length + GC_MESSAGE_PSEUDO_ID_SIZE;
+    uint8_t *message_with_type = (uint8_t *)malloc(raw_length);
 
     if (message_with_type == nullptr) {
         return -6;
     }
 
     message_with_type[0] = type;
-    memcpy(message_with_type + 1, message, length);
 
-    uint8_t *packet = (uint8_t *)malloc(length + 1 + GC_BROADCAST_ENC_HEADER_SIZE);
+    const uint32_t pseudo_msg_id = random_u32(chat->rng);
+    net_pack_u32(message_with_type + 1, pseudo_msg_id);
+
+    memcpy(message_with_type + 1 + GC_MESSAGE_PSEUDO_ID_SIZE, message, length);
+
+    uint8_t *packet = (uint8_t *)malloc(raw_length + GC_BROADCAST_ENC_HEADER_SIZE);
 
     if (packet == nullptr) {
         free(message_with_type);
         return -6;
     }
 
-    const uint16_t packet_len = make_gc_broadcast_header(message_with_type, length + 1, packet, GM_PRIVATE_MESSAGE);
+    const uint16_t packet_len = make_gc_broadcast_header(message_with_type, raw_length, packet, GM_PRIVATE_MESSAGE);
 
     free(message_with_type);
 
@@ -5008,6 +5014,10 @@ int gc_send_private_message(const GC_Chat *chat, GC_Peer_Id peer_id, uint8_t typ
 
     free(packet);
 
+    if (message_id != nullptr) {
+        *message_id = pseudo_msg_id;
+    }
+
     return 0;
 }
 
@@ -5020,7 +5030,7 @@ non_null(1, 2, 3, 4) nullable(6)
 static int handle_gc_private_message(const GC_Session *c, const GC_Chat *chat, const GC_Peer *peer, const uint8_t *data,
                                      uint16_t length, void *userdata)
 {
-    if (data == nullptr || length > MAX_GC_MESSAGE_SIZE || length <= 1) {
+    if (data == nullptr || length > MAX_GC_MESSAGE_SIZE || length <= 1 + GC_MESSAGE_PSEUDO_ID_SIZE) {
         return -1;
     }
 
@@ -5035,8 +5045,13 @@ static int handle_gc_private_message(const GC_Session *c, const GC_Chat *chat, c
         return 0;
     }
 
+    uint32_t message_id;
+    net_unpack_u32(data + 1, &message_id);
+
     if (c->private_message != nullptr) {
-        c->private_message(c->messenger, chat->group_number, peer->peer_id, message_type, data + 1, length - 1, userdata);
+        c->private_message(c->messenger, chat->group_number, peer->peer_id, message_type,
+                           data + 1 + GC_MESSAGE_PSEUDO_ID_SIZE, length - 1 - GC_MESSAGE_PSEUDO_ID_SIZE,
+                           message_id, userdata);
     }
 
     return 0;
diff --git a/toxcore/group_chats.h b/toxcore/group_chats.h
@@ -181,9 +181,9 @@ int gc_send_message(const GC_Chat *chat, const uint8_t *message, uint16_t length
  * Returns -5 if the sender has the observer role.
  * Returns -6 if the packet fails to send.
  */
-non_null()
+non_null(1, 4) nullable(6)
 int gc_send_private_message(const GC_Chat *chat, GC_Peer_Id peer_id, uint8_t type, const uint8_t *message,
-                            uint16_t length);
+                            uint16_t length, uint32_t *message_id);
 
 /** @brief Sends a custom packet to the group. If lossless is true, the packet will be lossless.
  *
diff --git a/toxcore/group_common.h b/toxcore/group_common.h
@@ -348,7 +348,7 @@ typedef struct Messenger Messenger;
 typedef void gc_message_cb(const Messenger *m, uint32_t group_number, GC_Peer_Id peer_id, unsigned int type,
                            const uint8_t *message, size_t length, uint32_t message_id, void *user_data);
 typedef void gc_private_message_cb(const Messenger *m, uint32_t group_number, GC_Peer_Id peer_id, unsigned int type,
-                                   const uint8_t *message, size_t length, void *user_data);
+                                   const uint8_t *message, size_t length, uint32_t message_id, void *user_data);
 typedef void gc_custom_packet_cb(const Messenger *m, uint32_t group_number, GC_Peer_Id peer_id, const uint8_t *data,
                                  size_t length, void *user_data);
 typedef void gc_custom_private_packet_cb(const Messenger *m, uint32_t group_number, GC_Peer_Id peer_id,
diff --git a/toxcore/tox.c b/toxcore/tox.c
@@ -536,16 +536,16 @@ static void tox_group_message_handler(const Messenger *m, uint32_t group_number,
     }
 }
 
-non_null(1, 5) nullable(7)
+non_null(1, 5) nullable(8)
 static void tox_group_private_message_handler(const Messenger *m, uint32_t group_number, GC_Peer_Id peer_id,
-        unsigned int type, const uint8_t *message, size_t length, void *user_data)
+        unsigned int type, const uint8_t *message, size_t length, uint32_t message_id, void *user_data)
 {
     struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;
 
     if (tox_data->tox->group_private_message_callback != nullptr) {
         tox_unlock(tox_data->tox);
         tox_data->tox->group_private_message_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), (Tox_Message_Type)type, message,
-                length, tox_data->user_data);
+                length, message_id, tox_data->user_data);
         tox_lock(tox_data->tox);
     }
 }
@@ -3994,8 +3994,8 @@ Tox_Group_Message_Id tox_group_send_message(
     return -1;
 }
 
-bool tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type,
-                                    const uint8_t *message, size_t length, Tox_Err_Group_Send_Private_Message *error)
+Tox_Group_Message_Id tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint32_t peer_id,
+        Tox_Message_Type type, const uint8_t *message, size_t length, Tox_Err_Group_Send_Private_Message *error)
 {
     assert(tox != nullptr);
 
@@ -4005,59 +4005,60 @@ bool tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint3
     if (chat == nullptr) {
         SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND);
         tox_unlock(tox);
-        return false;
+        return -1;
     }
 
     if (chat->connection_state == CS_DISCONNECTED) {
         SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED);
         tox_unlock(tox);
-        return false;
+        return -1;
     }
 
-    const int ret = gc_send_private_message(chat, gc_peer_id_from_int(peer_id), type, message, length);
+    uint32_t message_id = 0;
+    const int ret = gc_send_private_message(chat, gc_peer_id_from_int(peer_id), type, message, length, &message_id);
     tox_unlock(tox);
 
     switch (ret) {
         case 0: {
             SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK);
-            return true;
+            return message_id;
         }
 
         case -1: {
             SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG);
-            return false;
+            return -1;
         }
 
         case -2: {
             SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY);
-            return false;
+            return -1;
         }
 
         case -3: {
             SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND);
-            return false;
+            return -1;
         }
 
         case -4: {
             SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_BAD_TYPE);
-            return false;
+            return -1;
         }
 
         case -5: {
             SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS);
-            return false;
+            return -1;
         }
 
         case -6: {
             SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND);
-            return false;
+            return -1;
         }
     }
 
     /* can't happen */
     LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret);
 
-    return false;
+    return -1;
 }
 
 bool tox_group_send_custom_packet(const Tox *tox, uint32_t group_number, bool lossless, const uint8_t *data,
diff --git a/toxcore/tox.h b/toxcore/tox.h
@@ -4575,7 +4575,7 @@ const char *tox_err_group_send_private_message_to_string(Tox_Err_Group_Send_Priv
  *
  * @return true on success.
  */
-bool tox_group_send_private_message(
+Tox_Group_Message_Id tox_group_send_private_message(
     const Tox *tox, Tox_Group_Number group_number, Tox_Group_Peer_Number peer_id, Tox_Message_Type type,
     const uint8_t message[], size_t length,
     Tox_Err_Group_Send_Private_Message *error);
@@ -4753,7 +4753,7 @@ void tox_callback_group_message(Tox *tox, tox_group_message_cb *callback);
  */
 typedef void tox_group_private_message_cb(
     Tox *tox, Tox_Group_Number group_number, Tox_Group_Peer_Number peer_id, Tox_Message_Type type,
-    const uint8_t message[], size_t length, void *user_data);
+    const uint8_t message[], size_t length, uint32_t message_id, void *user_data);
 
 /**
  * Set the callback for the `group_private_message` event. Pass NULL to unset.
diff --git a/toxcore/tox_events.h b/toxcore/tox_events.h

Original file line number	Diff line number	Diff line change
`@@ -757,6 +757,7 @@ int main(int argc, char** argv) {`
`757`	`757`	`EventTypeTrivial{"uint32_t", "peer_id"},`
`758`	`758`	`EventTypeTrivial{"Tox_Message_Type", "type"},`
`759`	`759`	`EventTypeByteRange{"message", "message_length", "length"}, // the latter two are ideally the same`
	`760`	`+ EventTypeTrivial{"uint32_t", "message_id"},`
`760`	`761`	`}`
`761`	`762`	`},`
`762`	`763`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4911,11 +4911,12 @@ int gc_send_message(const GC_Chat chat, const uint8_t message, uint16_t length`
`4911`	`4911`	`return -5;`
`4912`	`4912`	`}`
`4913`	`4913`
	`4914`	`+ free(message_raw);`
	`4915`	`+`
`4914`	`4916`	`if (message_id != nullptr) {`
`4915`	`4917`	`*message_id = pseudo_msg_id;`
`4916`	`4918`	`}`
`4917`	`4919`
`4918`		`- free(message_raw);`
`4919`	`4920`	`return 0;`
`4920`	`4921`	`}`
`4921`	`4922`
`@@ -4955,7 +4956,7 @@ static int handle_gc_message(const GC_Session c, const GC_Chat chat, const GC_`
`4955`	`4956`	`}`
`4956`	`4957`
`4957`	`4958`	`int gc_send_private_message(const GC_Chat chat, GC_Peer_Id peer_id, uint8_t type, const uint8_t message,`
`4958`		`- uint16_t length)`
	`4959`	`+ uint16_t length, uint32_t *message_id)`
`4959`	`4960`	`{`
`4960`	`4961`	`if (length > MAX_GC_MESSAGE_SIZE) {`
`4961`	`4962`	`return -1;`
`@@ -4981,23 +4982,28 @@ int gc_send_private_message(const GC_Chat *chat, GC_Peer_Id peer_id, uint8_t typ`
`4981`	`4982`	`return -5;`
`4982`	`4983`	`}`
`4983`	`4984`
`4984`		`- uint8_t message_with_type = (uint8_t )malloc(length + 1);`
	`4985`	`+ const uint16_t raw_length = 1 + length + GC_MESSAGE_PSEUDO_ID_SIZE;`
	`4986`	`+ uint8_t message_with_type = (uint8_t )malloc(raw_length);`
`4985`	`4987`
`4986`	`4988`	`if (message_with_type == nullptr) {`
`4987`	`4989`	`return -6;`
`4988`	`4990`	`}`
`4989`	`4991`
`4990`	`4992`	`message_with_type[0] = type;`
`4991`		`- memcpy(message_with_type + 1, message, length);`
`4992`	`4993`
`4993`		`- uint8_t packet = (uint8_t )malloc(length + 1 + GC_BROADCAST_ENC_HEADER_SIZE);`
	`4994`	`+ const uint32_t pseudo_msg_id = random_u32(chat->rng);`
	`4995`	`+ net_pack_u32(message_with_type + 1, pseudo_msg_id);`
	`4996`	`+`
	`4997`	`+ memcpy(message_with_type + 1 + GC_MESSAGE_PSEUDO_ID_SIZE, message, length);`
	`4998`	`+`
	`4999`	`+ uint8_t packet = (uint8_t )malloc(raw_length + GC_BROADCAST_ENC_HEADER_SIZE);`
`4994`	`5000`
`4995`	`5001`	`if (packet == nullptr) {`
`4996`	`5002`	`free(message_with_type);`
`4997`	`5003`	`return -6;`
`4998`	`5004`	`}`
`4999`	`5005`
`5000`		`- const uint16_t packet_len = make_gc_broadcast_header(message_with_type, length + 1, packet, GM_PRIVATE_MESSAGE);`
	`5006`	`+ const uint16_t packet_len = make_gc_broadcast_header(message_with_type, raw_length, packet, GM_PRIVATE_MESSAGE);`
`5001`	`5007`
`5002`	`5008`	`free(message_with_type);`
`5003`	`5009`
`@@ -5008,6 +5014,10 @@ int gc_send_private_message(const GC_Chat *chat, GC_Peer_Id peer_id, uint8_t typ`
`5008`	`5014`
`5009`	`5015`	`free(packet);`
`5010`	`5016`
	`5017`	`+ if (message_id != nullptr) {`
	`5018`	`+ *message_id = pseudo_msg_id;`
	`5019`	`+ }`
	`5020`	`+`
`5011`	`5021`	`return 0;`
`5012`	`5022`	`}`
`5013`	`5023`
`@@ -5020,7 +5030,7 @@ non_null(1, 2, 3, 4) nullable(6)`
`5020`	`5030`	`static int handle_gc_private_message(const GC_Session c, const GC_Chat chat, const GC_Peer peer, const uint8_t data,`
`5021`	`5031`	`uint16_t length, void *userdata)`
`5022`	`5032`	`{`
`5023`		`- if (data == nullptr \|\| length > MAX_GC_MESSAGE_SIZE \|\| length <= 1) {`
	`5033`	`+ if (data == nullptr \|\| length > MAX_GC_MESSAGE_SIZE \|\| length <= 1 + GC_MESSAGE_PSEUDO_ID_SIZE) {`
`5024`	`5034`	`return -1;`
`5025`	`5035`	`}`
`5026`	`5036`
`@@ -5035,8 +5045,13 @@ static int handle_gc_private_message(const GC_Session c, const GC_Chat chat, c`
`5035`	`5045`	`return 0;`
`5036`	`5046`	`}`
`5037`	`5047`
	`5048`	`+ uint32_t message_id;`
	`5049`	`+ net_unpack_u32(data + 1, &message_id);`
	`5050`	`+`
`5038`	`5051`	`if (c->private_message != nullptr) {`
`5039`		`- c->private_message(c->messenger, chat->group_number, peer->peer_id, message_type, data + 1, length - 1, userdata);`
	`5052`	`+ c->private_message(c->messenger, chat->group_number, peer->peer_id, message_type,`
	`5053`	`+ data + 1 + GC_MESSAGE_PSEUDO_ID_SIZE, length - 1 - GC_MESSAGE_PSEUDO_ID_SIZE,`
	`5054`	`+ message_id, userdata);`
`5040`	`5055`	`}`
`5041`	`5056`
`5042`	`5057`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -536,16 +536,16 @@ static void tox_group_message_handler(const Messenger *m, uint32_t group_number,`
`536`	`536`	`}`
`537`	`537`	`}`
`538`	`538`
`539`		`-non_null(1, 5) nullable(7)`
	`539`	`+non_null(1, 5) nullable(8)`
`540`	`540`	`static void tox_group_private_message_handler(const Messenger *m, uint32_t group_number, GC_Peer_Id peer_id,`
`541`		`- unsigned int type, const uint8_t message, size_t length, void user_data)`
	`541`	`+ unsigned int type, const uint8_t message, size_t length, uint32_t message_id, void user_data)`
`542`	`542`	`{`
`543`	`543`	`struct Tox_Userdata tox_data = (struct Tox_Userdata )user_data;`
`544`	`544`
`545`	`545`	`if (tox_data->tox->group_private_message_callback != nullptr) {`
`546`	`546`	`tox_unlock(tox_data->tox);`
`547`	`547`	`tox_data->tox->group_private_message_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), (Tox_Message_Type)type, message,`
`548`		`- length, tox_data->user_data);`
	`548`	`+ length, message_id, tox_data->user_data);`
`549`	`549`	`tox_lock(tox_data->tox);`
`550`	`550`	`}`
`551`	`551`	`}`
`@@ -3994,8 +3994,8 @@ Tox_Group_Message_Id tox_group_send_message(`
`3994`	`3994`	`return -1;`
`3995`	`3995`	`}`
`3996`	`3996`
`3997`		`-bool tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type,`
`3998`		`- const uint8_t message, size_t length, Tox_Err_Group_Send_Private_Message error)`
	`3997`	`+Tox_Group_Message_Id tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint32_t peer_id,`
	`3998`	`+ Tox_Message_Type type, const uint8_t message, size_t length, Tox_Err_Group_Send_Private_Message error)`
`3999`	`3999`	`{`
`4000`	`4000`	`assert(tox != nullptr);`
`4001`	`4001`
`@@ -4005,59 +4005,60 @@ bool tox_group_send_private_message(const Tox *tox, uint32_t group_number, uint3`
`4005`	`4005`	`if (chat == nullptr) {`
`4006`	`4006`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND);`
`4007`	`4007`	`tox_unlock(tox);`
`4008`		`- return false;`
	`4008`	`+ return -1;`
`4009`	`4009`	`}`
`4010`	`4010`
`4011`	`4011`	`if (chat->connection_state == CS_DISCONNECTED) {`
`4012`	`4012`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED);`
`4013`	`4013`	`tox_unlock(tox);`
`4014`		`- return false;`
	`4014`	`+ return -1;`
`4015`	`4015`	`}`
`4016`	`4016`
`4017`		`- const int ret = gc_send_private_message(chat, gc_peer_id_from_int(peer_id), type, message, length);`
	`4017`	`+ uint32_t message_id = 0;`
	`4018`	`+ const int ret = gc_send_private_message(chat, gc_peer_id_from_int(peer_id), type, message, length, &message_id);`
`4018`	`4019`	`tox_unlock(tox);`
`4019`	`4020`
`4020`	`4021`	`switch (ret) {`
`4021`	`4022`	`case 0: {`
`4022`	`4023`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK);`
`4023`		`- return true;`
	`4024`	`+ return message_id;`
`4024`	`4025`	`}`
`4025`	`4026`
`4026`	`4027`	`case -1: {`
`4027`	`4028`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG);`
`4028`		`- return false;`
	`4029`	`+ return -1;`
`4029`	`4030`	`}`
`4030`	`4031`
`4031`	`4032`	`case -2: {`
`4032`	`4033`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY);`
`4033`		`- return false;`
	`4034`	`+ return -1;`
`4034`	`4035`	`}`
`4035`	`4036`
`4036`	`4037`	`case -3: {`
`4037`	`4038`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND);`
`4038`		`- return false;`
	`4039`	`+ return -1;`
`4039`	`4040`	`}`
`4040`	`4041`
`4041`	`4042`	`case -4: {`
`4042`	`4043`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_BAD_TYPE);`
`4043`		`- return false;`
	`4044`	`+ return -1;`
`4044`	`4045`	`}`
`4045`	`4046`
`4046`	`4047`	`case -5: {`
`4047`	`4048`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS);`
`4048`		`- return false;`
	`4049`	`+ return -1;`
`4049`	`4050`	`}`
`4050`	`4051`
`4051`	`4052`	`case -6: {`
`4052`	`4053`	`SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND);`
`4053`		`- return false;`
	`4054`	`+ return -1;`
`4054`	`4055`	`}`
`4055`	`4056`	`}`
`4056`	`4057`
`4057`	`4058`	`/* can't happen */`
`4058`	`4059`	`LOGGER_FATAL(tox->m->log, "impossible return value: %d", ret);`
`4059`	`4060`
`4060`		`- return false;`
	`4061`	`+ return -1;`
`4061`	`4062`	`}`
`4062`	`4063`
`4063`	`4064`	`bool tox_group_send_custom_packet(const Tox tox, uint32_t group_number, bool lossless, const uint8_t data,`