Some code written for new group chats.

1 files changed, 331 insertions, 0 deletions

diff --git a/toxcore/group.c b/toxcore/group.c
new file mode 100644
index 00000000..65ae078c
--- /dev/null
+++ b/toxcore/group.c
@@ -0,0 +1,331 @@
+/* group.c
+ *
+ * Slightly better groupchats implementation.
+ *
+ *  Copyright (C) 2014 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox 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.
+ *
+ *  Tox 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 Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+ 
+#include "group.h"
+#include "util.h"
+
+/* return 1 if the con_number is not valid.
+ * return 0 if the con_number is valid.
+ */
+static uint8_t con_number_not_valid(const Group_Chats *g_c, int con_number)
+{
+    if ((unsigned int)con_number >= g_c->num_cons)
+        return 1;
+
+    if (g_c->cons == NULL)
+        return 1;
+
+    if (g_c->cons[con_number].status == GROUPCON_STATUS_NONE)
+        return 1;
+
+    return 0;
+}
+
+
+/* Set the size of the groupchat connections list to num.
+ *
+ *  return -1 if realloc fails.
+ *  return 0 if it succeeds.
+ */
+static int realloc_groupcons(Group_Chats *g_c, uint32_t num)
+{
+    if (num == 0) {
+        free(g_c->cons);
+        g_c->cons = NULL;
+        return 0;
+    }
+
+    Group_Connection *newgroup_cons = realloc(g_c->cons, num * sizeof(Group_Connection));
+
+    if (newgroup_cons == NULL)
+        return -1;
+
+    g_c->cons = newgroup_cons;
+    return 0;
+}
+
+/* Create a new empty groupchat connection.
+ *
+ * return -1 on failure.
+ * return con_number on success.
+ */
+static int create_group_con(Group_Chats *g_c)
+{
+    uint32_t i;
+
+    for (i = 0; i < g_c->num_cons; ++i) {
+        if (g_c->cons[i].status == GROUPCON_STATUS_NONE)
+            return i;
+    }
+
+    int id = -1;
+
+    if (realloc_groupcons(g_c, g_c->num_cons + 1) == 0) {
+        id = g_c->num_cons;
+        ++g_c->num_cons;
+        memset(&(g_c->cons[id]), 0, sizeof(Group_Connection));
+    }
+
+    return id;
+}
+
+/* Wipe a groupchat connection.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+static int wipe_group_con(Group_Chats *g_c, int con_number)
+{
+    if (con_number_not_valid(g_c, con_number))
+        return -1;
+
+    uint32_t i;
+    memset(&(g_c->cons[con_number]), 0 , sizeof(Group_c));
+
+    for (i = g_c->num_cons; i != 0; --i) {
+        if (g_c->cons[i - 1].status != GROUPCON_STATUS_NONE)
+            break;
+    }
+
+    if (g_c->num_cons != i) {
+        g_c->num_cons = i;
+        realloc_groupcons(g_c, g_c->num_cons);
+    }
+
+    return 0;
+}
+
+static Group_Connection *get_con_group(Group_Chats *g_c, int con_number)
+{
+    if (con_number_not_valid(g_c, con_number))
+        return 0;
+
+    return &g_c->cons[con_number];
+}
+
+/* return 1 if the groupnumber is not valid.
+ * return 0 if the groupnumber is valid.
+ */
+static uint8_t groupnumber_not_valid(const Group_Chats *g_c, int groupnumber)
+{
+    if ((unsigned int)groupnumber >= g_c->num_chats)
+        return 1;
+
+    if (g_c->chats == NULL)
+        return 1;
+
+    if (g_c->chats[groupnumber].status == GROUPCHAT_STATUS_NONE)
+        return 1;
+
+    return 0;
+}
+
+
+/* Set the size of the groupchat list to num.
+ *
+ *  return -1 if realloc fails.
+ *  return 0 if it succeeds.
+ */
+static int realloc_groupchats(Group_Chats *g_c, uint32_t num)
+{
+    if (num == 0) {
+        free(g_c->chats);
+        g_c->chats = NULL;
+        return 0;
+    }
+
+    Group_c *newgroup_chats = realloc(g_c->chats, num * sizeof(Group_c));
+
+    if (newgroup_chats == NULL)
+        return -1;
+
+    g_c->chats = newgroup_chats;
+    return 0;
+}
+
+
+/* Create a new empty groupchat connection.
+ *
+ * return -1 on failure.
+ * return groupnumber on success.
+ */
+static int create_group_chat(Group_Chats *g_c)
+{
+    uint32_t i;
+
+    for (i = 0; i < g_c->num_chats; ++i) {
+        if (g_c->chats[i].status == GROUPCHAT_STATUS_NONE)
+            return i;
+    }
+
+    int id = -1;
+
+    if (realloc_groupchats(g_c, g_c->num_chats + 1) == 0) {
+        id = g_c->num_chats;
+        ++g_c->num_chats;
+        memset(&(g_c->chats[id]), 0, sizeof(Group_c));
+    }
+
+    return id;
+}
+
+
+/* Wipe a groupchat.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+static int wipe_group_chat(Group_Chats *g_c, int groupnumber)
+{
+    if (groupnumber_not_valid(g_c, groupnumber))
+        return -1;
+
+    uint32_t i;
+    memset(&(g_c->chats[groupnumber]), 0 , sizeof(Group_c));
+
+    for (i = g_c->num_chats; i != 0; --i) {
+        if (g_c->chats[i - 1].status != GROUPCHAT_STATUS_NONE)
+            break;
+    }
+
+    if (g_c->num_chats != i) {
+        g_c->num_chats = i;
+        realloc_groupchats(g_c, g_c->num_chats);
+    }
+
+    return 0;
+}
+
+static Group_c *get_group_c(Group_Chats *g_c, int groupnumber)
+{
+    if (groupnumber_not_valid(g_c, groupnumber))
+        return 0;
+
+    return &g_c->chats[groupnumber];
+}
+
+/*
+ * check if peer with client_id is in peer array.
+ *
+ * return peer number if peer is in chat.
+ * return -1 if peer is not in chat.
+ *
+ * TODO: make this more efficient.
+ */
+
+static int peer_in_chat(const Group_c *chat, const uint8_t *client_id)
+{
+    uint32_t i;
+
+    for (i = 0; i < chat->numpeers; ++i)
+        if (id_equal(chat->group[i].client_id, client_id))
+            return i;
+
+    return -1;
+}
+
+/*
+ * Add a peer to the group chat.
+ *
+ * return peernum if success or peer already in chat.
+ * return -1 if error.
+ */
+static int addpeer(Group_c *chat, const uint8_t *client_id)
+{
+    int peernum = peer_in_chat(chat, client_id);
+
+    if (peernum != -1)
+        return peernum;
+
+    Group_Peer *temp;
+    temp = realloc(chat->group, sizeof(Group_Peer) * (chat->numpeers + 1));
+
+    if (temp == NULL)
+        return -1;
+
+    memset(&(temp[chat->numpeers]), 0, sizeof(Group_Peer));
+    chat->group = temp;
+
+    id_copy(chat->group[chat->numpeers].client_id, client_id);
+    chat->group[chat->numpeers].last_recv = unix_time();
+    chat->group[chat->numpeers].last_recv_msgping = unix_time();
+    ++chat->numpeers;
+
+    //if (chat->peer_namelistchange != NULL)
+    //    (*chat->peer_namelistchange)(chat, chat->numpeers - 1, CHAT_CHANGE_PEER_ADD, chat->group_namelistchange_userdata);
+
+    return (chat->numpeers - 1);
+}
+
+
+/* Creates a new groupchat and puts it in the chats array.
+ *
+ * return group number on success.
+ * return -1 on failure.
+ */
+int temp_c_add_groupchat(Group_Chats *g_c)
+{
+    int groupnumber = create_group_chat(g_c);
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g) {
+        return -1;
+    }
+
+    g->status = GROUPCHAT_STATUS_VALID;
+    return groupnumber;
+}
+
+/* Create new groupchat instance. */
+Group_Chats *new_groupchats(Messenger *m)
+{
+    if (!m)
+        return NULL;
+
+    Group_Chats *temp = calloc(1, sizeof(Group_Chats));
+
+    if (temp == NULL)
+        return NULL;
+
+    temp->m = m;
+    return temp;
+}
+
+/* main groupchats loop. */
+void do_groupchats(Group_Chats *g_c)
+{
+    //TODO
+}
+
+/* Free everything related with group chats. */
+void kill_groupchats(Group_Chats *g_c)
+{
+    //TODO
+    free(g_c);
+}
+