ffi-tox 0.1.1 → 0.1.3

data/ProjectTox-Core/toxcore/group_chats.h

@@ -0,0 +1,199 @@
+/* group_chats.h
+ *
+ * An implementation of massive text only group chats.
+ *
+ *
+ *  Copyright (C) 2013 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/>.
+ *
+ */
+
+#ifndef GROUP_CHATS_H
+#define GROUP_CHATS_H
+
+#define MAX_NICK_BYTES 128
+
+typedef struct {
+    uint8_t     client_id[crypto_box_PUBLICKEYBYTES];
+    uint64_t    pingid;
+    uint64_t    last_pinged;
+    IP_Port     ping_via;
+
+    uint64_t    last_recv;
+    uint64_t    last_recv_msgping;
+    uint32_t    last_message_number;
+
+    uint8_t     nick[MAX_NICK_BYTES];
+    uint16_t    nick_len;
+
+    uint8_t     deleted;
+    uint64_t    deleted_time;
+} Group_Peer;
+
+typedef struct {
+    uint8_t     client_id[crypto_box_PUBLICKEYBYTES];
+    IP_Port     ip_port;
+    uint64_t    last_recv;
+} Group_Close;
+
+#define GROUP_CLOSE_CONNECTIONS 6
+
+typedef struct Group_Chat {
+    Networking_Core *net;
+    uint8_t     self_public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t     self_secret_key[crypto_box_SECRETKEYBYTES];
+
+    Group_Peer *group;
+    Group_Close  close[GROUP_CLOSE_CONNECTIONS];
+    uint32_t numpeers;
+
+    uint32_t message_number;
+    void (*group_message)(struct Group_Chat *m, int, const uint8_t *, uint16_t, void *);
+    void *group_message_userdata;
+    void (*group_action)(struct Group_Chat *m, int, const uint8_t *, uint16_t, void *);
+    void *group_action_userdata;
+    void (*peer_namelistchange)(struct Group_Chat *m, int peer, uint8_t change, void *);
+    void *group_namelistchange_userdata;
+
+    uint64_t last_sent_ping;
+
+    uint8_t        nick[MAX_NICK_BYTES];
+    uint16_t       nick_len;
+    uint64_t       last_sent_nick;
+
+    struct Assoc  *assoc;
+} Group_Chat;
+
+#define GROUP_CHAT_PING 0
+#define GROUP_CHAT_NEW_PEER 16
+#define GROUP_CHAT_QUIT 24
+#define GROUP_CHAT_PEER_NICK 48
+#define GROUP_CHAT_CHAT_MESSAGE 64
+#define GROUP_CHAT_ACTION 63
+
+/* Copy the name of peernum to name.
+ * name must be at least MAX_NICK_BYTES long.
+ *
+ * return length of name if success
+ * return -1 if failure
+ */
+int group_peername(const Group_Chat *chat, int peernum, uint8_t *name);
+
+/*
+ * Set callback function for chat messages.
+ *
+ * format of function is: function(Group_Chat *chat, peer number, message, message length, userdata)
+ */
+void callback_groupmessage(Group_Chat *chat, void (*function)(Group_Chat *chat, int, const uint8_t *, uint16_t, void *),
+                           void *userdata);
+
+/*
+ * Set callback function for actions.
+ *
+ * format of function is: function(Group_Chat *chat, peer number, action, action length, userdata)
+ */
+void callback_groupaction(Group_Chat *chat, void (*function)(Group_Chat *chat, int, const uint8_t *, uint16_t, void *),
+                          void *userdata);
+
+/*
+ * Set callback function for peer name list changes.
+ *
+ * It gets called every time the name list changes(new peer/name, deleted peer)
+ *
+ * format of function is: function(Group_Chat *chat, userdata)
+ */
+typedef enum {
+    CHAT_CHANGE_PEER_ADD,
+    CHAT_CHANGE_PEER_DEL,
+    CHAT_CHANGE_PEER_NAME,
+} CHAT_CHANGE;
+
+void callback_namelistchange(Group_Chat *chat, void (*function)(Group_Chat *chat, int peer, uint8_t change, void *),
+                             void *userdata);
+
+/*
+ * Send a message to the group.
+ *
+ * returns the number of peers it has sent it to.
+ */
+uint32_t group_sendmessage(Group_Chat *chat, const uint8_t *message, uint32_t length);
+
+/*
+ * Send an action to the group.
+ *
+ * returns the number of peers it has sent it to.
+ */
+uint32_t group_sendaction(Group_Chat *chat, const uint8_t *action, uint32_t length);
+
+/*
+ * Set our nick for this group.
+ *
+ * returns -1 on failure, 0 on success.
+ */
+int set_nick(Group_Chat *chat, const uint8_t *nick, uint16_t nick_len);
+
+/*
+ * Tell everyone about a new peer (a person we are inviting for example.)
+ *
+ */
+uint32_t group_newpeer(Group_Chat *chat, const uint8_t *client_id);
+
+
+/* Create a new group chat.
+ *
+ * Returns a new group chat instance if success.
+ *
+ * Returns a NULL pointer if fail.
+ */
+Group_Chat *new_groupchat(Networking_Core *net);
+
+
+/* Return the number of peers in the group chat.
+ */
+uint32_t group_numpeers(const Group_Chat *chat);
+
+/* List all the peers in the group chat.
+ *
+ * Copies the names of the peers to the name[length][MAX_NICK_BYTES] array.
+ *
+ * returns the number of peers.
+ */
+uint32_t group_client_names(const Group_Chat *chat, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[],
+                            uint16_t length);
+
+/* Kill a group chat
+ *
+ * Frees the memory and everything.
+ */
+void kill_groupchat(Group_Chat *chat);
+
+/*
+ * This is the main loop.
+ */
+void do_groupchat(Group_Chat *chat);
+
+/* if we receive a group chat packet we call this function so it can be handled.
+    return 0 if packet is handled correctly.
+    return 1 if it didn't handle the packet or if the packet was shit. */
+int handle_groupchatpacket(Group_Chat *chat, IP_Port source, const uint8_t *packet, uint32_t length);
+
+
+void chat_bootstrap(Group_Chat *chat, IP_Port ip_port, const uint8_t *client_id);
+void chat_bootstrap_nonlazy(Group_Chat *chat, IP_Port ip_port, const uint8_t *client_id);
+
+
+#endif

data/ProjectTox-Core/toxcore/list.c

@@ -0,0 +1,256 @@
+/* list.h
+ *
+ * Simple struct with functions to create a list which associates ids with data
+ * -Allows for finding ids associated with data such as IPs or public keys in a short time
+ * -Should only be used if there are relatively few add/remove calls to the list
+ *
+ *  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/>.
+ *
+ */
+
+#include "list.h"
+
+/* Basically, the elements in the list are placed in order so that they can be searched for easily
+ * -each element is seen as a big-endian integer when ordering them
+ * -the ids array is maintained so that each id always matches
+ * -the search algorithm cuts down the time to find the id associated with a piece of data
+ *   at the cost of slow add/remove functions for large lists
+ * -Starts at 1/2 of the array, compares the element in the array with the data,
+ *   then moves +/- 1/4 of the array depending on whether the value is greater or lower,
+ *   then +- 1/8, etc, until the value is matched or its position where it should be in the array is found
+ * -some considerations since the array size is never perfect
+ */
+
+#define INDEX(i) (~i)
+
+/* Find data in list
+ *
+ * return value:
+ *  >= 0 : index of data in array
+ *  < 0  : no match, returns index (return value is INDEX(index)) where
+ *         the data should be inserted
+ */
+static int find(const BS_LIST *list, const void *data)
+{
+    //should work well, but could be improved
+    if (list->n == 0) {
+        return INDEX(0);
+    }
+
+    uint32_t i = list->n / 2; //current position in the array
+    uint32_t delta = i / 2;   //how much we move in the array
+
+    if (!delta) {
+        delta = 1;
+    }
+
+    int d = -1; //used to determine if closest match is found
+    //closest match is found if we move back to where we have already been
+
+    while (1) {
+        int r = memcmp(data, list->data + list->element_size * i, list->element_size);
+
+        if (r == 0) {
+            return i;
+        }
+
+        if (r > 0) {
+            //data is greater
+            //move down
+            i += delta;
+
+            if (d == 0 || i == list->n) {
+                //reached bottom of list, or closest match
+                return INDEX(i);
+            }
+
+            delta = (delta) / 2;
+
+            if (delta == 0) {
+                delta = 1;
+                d = 1;
+            }
+        } else {
+            //data is smaller
+            if (d == 1 || i == 0) {
+                //reached top or list or closest match
+                return INDEX(i);
+            }
+
+            //move up
+            i -= delta;
+
+            delta = (delta) / 2;
+
+            if (delta == 0) {
+                delta = 1;
+                d = 0;
+            }
+        }
+    }
+}
+
+/* Resized the list list
+ *
+ * return value:
+ *  1 : success
+ *  0 : failure
+ */
+static int resize(BS_LIST *list, uint32_t new_size)
+{
+    void *p;
+
+    p = realloc(list->data, list->element_size * new_size);
+
+    if (!p) {
+        return 0;
+    } else {
+        list->data = p;
+    }
+
+    p = realloc(list->ids, sizeof(int) * new_size);
+
+    if (!p) {
+        return 0;
+    } else {
+        list->ids = p;
+    }
+
+    return 1;
+}
+
+
+int bs_list_init(BS_LIST *list, uint32_t element_size, uint32_t initial_capacity)
+{
+    //set initial values
+    list->n = 0;
+    list->element_size = element_size;
+    list->capacity = 0;
+    list->data = NULL;
+    list->ids = NULL;
+
+    if (initial_capacity != 0) {
+        if (!resize(list, initial_capacity)) {
+            return 0;
+        }
+    }
+
+    list->capacity = initial_capacity;
+
+    return 1;
+}
+
+void bs_list_free(BS_LIST *list)
+{
+    //free both arrays
+    free(list->data);
+    free(list->ids);
+}
+
+int bs_list_find(const BS_LIST *list, const void *data)
+{
+    int r = find(list, data);
+
+    //return only -1 and positive values
+    if (r < 0) {
+        return -1;
+    }
+
+    return list->ids[r];
+}
+
+int bs_list_add(BS_LIST *list, const void *data, int id)
+{
+    //find where the new element should be inserted
+    //see: return value of find()
+    int i = find(list, data);
+
+    if (i >= 0) {
+        //already in list
+        return 0;
+    }
+
+    i = ~i;
+
+    //increase the size of the arrays if needed
+    if (list->n == list->capacity) {
+        // 1.5 * n + 1
+        const uint32_t new_capacity = list->n + list->n / 2 + 1;
+
+        if (!resize(list, new_capacity)) {
+            return 0;
+        }
+
+        list->capacity = new_capacity;
+    }
+
+    //insert data to element array
+    memmove(list->data + (i + 1) * list->element_size, list->data + i * list->element_size,
+            (list->n - i) * list->element_size);
+    memcpy(list->data + i * list->element_size, data, list->element_size);
+
+    //insert id to id array
+    memmove(&list->ids[i + 1], &list->ids[i], (list->n - i) * sizeof(int));
+    list->ids[i] = id;
+
+    //increase n
+    list->n++;
+
+    return 1;
+}
+
+int bs_list_remove(BS_LIST *list, const void *data, int id)
+{
+    int i = find(list, data);
+
+    if (i < 0) {
+        return 0;
+    }
+
+    if (list->ids[i] != id) {
+        //this should never happen
+        return 0;
+    }
+
+    //decrease the size of the arrays if needed
+    if (list->n < list->capacity / 2) {
+        const uint32_t new_capacity = list->capacity / 2;
+
+        if (resize(list, new_capacity)) {
+            list->capacity = new_capacity;
+        }
+    }
+
+    list->n--;
+
+    memmove(list->data + i * list->element_size, list->data + (i + 1) * list->element_size,
+            (list->n - i) * list->element_size);
+    memmove(&list->ids[i], &list->ids[i + 1], (list->n - i) * sizeof(int));
+
+    return 1;
+}
+
+int bs_list_trim(BS_LIST *list)
+{
+    if (!resize(list, list->n)) {
+        return 0;
+    }
+
+    list->capacity = list->n;
+    return 1;
+}