diff options
Diffstat (limited to 'libs/libtox/src/toxcore/Messenger.c')
| -rw-r--r-- | libs/libtox/src/toxcore/Messenger.c | 3155 |
1 files changed, 3155 insertions, 0 deletions
diff --git a/libs/libtox/src/toxcore/Messenger.c b/libs/libtox/src/toxcore/Messenger.c new file mode 100644 index 0000000000..4dd7d0c4a4 --- /dev/null +++ b/libs/libtox/src/toxcore/Messenger.c @@ -0,0 +1,3155 @@ +/* + * An implementation of a simple text chat only messenger on the tox network core. + */ + +/* + * Copyright © 2016-2017 The TokTok team. + * Copyright © 2013 Tox project. + * + * This file is part of Tox, the free peer to peer instant messenger. + * + * 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 "Messenger.h" + +#include "logger.h" +#include "network.h" +#include "util.h" + +#include <assert.h> + +static void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata); +static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data, + uint32_t length, uint8_t congestion_control); + +// friend_not_valid determines if the friendnumber passed is valid in the Messenger object +static uint8_t friend_not_valid(const Messenger *m, int32_t friendnumber) +{ + if ((unsigned int)friendnumber < m->numfriends) { + if (m->friendlist[friendnumber].status != 0) { + return 0; + } + } + + return 1; +} + +/* Set the size of the friend list to numfriends. + * + * return -1 if realloc fails. + */ +static int realloc_friendlist(Messenger *m, uint32_t num) +{ + if (num == 0) { + free(m->friendlist); + m->friendlist = NULL; + return 0; + } + + Friend *newfriendlist = (Friend *)realloc(m->friendlist, num * sizeof(Friend)); + + if (newfriendlist == NULL) { + return -1; + } + + m->friendlist = newfriendlist; + return 0; +} + +/* return the friend id associated to that public key. + * return -1 if no such friend. + */ +int32_t getfriend_id(const Messenger *m, const uint8_t *real_pk) +{ + uint32_t i; + + for (i = 0; i < m->numfriends; ++i) { + if (m->friendlist[i].status > 0) { + if (id_equal(real_pk, m->friendlist[i].real_pk)) { + return i; + } + } + } + + return -1; +} + +/* Copies the public key associated to that friend id into real_pk buffer. + * Make sure that real_pk is of size CRYPTO_PUBLIC_KEY_SIZE. + * + * return 0 if success. + * return -1 if failure. + */ +int get_real_pk(const Messenger *m, int32_t friendnumber, uint8_t *real_pk) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + memcpy(real_pk, m->friendlist[friendnumber].real_pk, CRYPTO_PUBLIC_KEY_SIZE); + return 0; +} + +/* return friend connection id on success. + * return -1 if failure. + */ +int getfriendcon_id(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + return m->friendlist[friendnumber].friendcon_id; +} + +/* + * return a uint16_t that represents the checksum of address of length len. + */ +static uint16_t address_checksum(const uint8_t *address, uint32_t len) +{ + uint8_t checksum[2] = {0}; + uint16_t check; + uint32_t i; + + for (i = 0; i < len; ++i) { + checksum[i % 2] ^= address[i]; + } + + memcpy(&check, checksum, sizeof(check)); + return check; +} + +/* Format: [real_pk (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)] + * + * return FRIEND_ADDRESS_SIZE byte address to give to others. + */ +void getaddress(const Messenger *m, uint8_t *address) +{ + id_copy(address, m->net_crypto->self_public_key); + uint32_t nospam = get_nospam(&(m->fr)); + memcpy(address + CRYPTO_PUBLIC_KEY_SIZE, &nospam, sizeof(nospam)); + uint16_t checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum)); + memcpy(address + CRYPTO_PUBLIC_KEY_SIZE + sizeof(nospam), &checksum, sizeof(checksum)); +} + +static int send_online_packet(Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return 0; + } + + uint8_t packet = PACKET_ID_ONLINE; + return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id), &packet, sizeof(packet), 0) != -1; +} + +static int send_offline_packet(Messenger *m, int friendcon_id) +{ + uint8_t packet = PACKET_ID_OFFLINE; + return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), &packet, + sizeof(packet), 0) != -1; +} + +static int m_handle_status(void *object, int i, uint8_t status, void *userdata); +static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata); +static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length, + void *userdata); + +static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t status) +{ + /* Resize the friend list if necessary. */ + if (realloc_friendlist(m, m->numfriends + 1) != 0) { + return FAERR_NOMEM; + } + + memset(&(m->friendlist[m->numfriends]), 0, sizeof(Friend)); + + int friendcon_id = new_friend_connection(m->fr_c, real_pk); + + if (friendcon_id == -1) { + return FAERR_NOMEM; + } + + uint32_t i; + + for (i = 0; i <= m->numfriends; ++i) { + if (m->friendlist[i].status == NOFRIEND) { + m->friendlist[i].status = status; + m->friendlist[i].friendcon_id = friendcon_id; + m->friendlist[i].friendrequest_lastsent = 0; + id_copy(m->friendlist[i].real_pk, real_pk); + m->friendlist[i].statusmessage_length = 0; + m->friendlist[i].userstatus = USERSTATUS_NONE; + m->friendlist[i].is_typing = 0; + m->friendlist[i].message_id = 0; + friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &m_handle_status, &m_handle_packet, + &m_handle_custom_lossy_packet, m, i); + + if (m->numfriends == i) { + ++m->numfriends; + } + + if (friend_con_connected(m->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) { + send_online_packet(m, i); + } + + return i; + } + } + + return FAERR_NOMEM; +} + +/* + * Add a friend. + * Set the data that will be sent along with friend request. + * Address is the address of the friend (returned by getaddress of the friend you wish to add) it must be FRIEND_ADDRESS_SIZE bytes. + * data is the data and length is the length. + * + * return the friend number if success. + * return FA_TOOLONG if message length is too long. + * return FAERR_NOMESSAGE if no message (message length must be >= 1 byte). + * return FAERR_OWNKEY if user's own key. + * return FAERR_ALREADYSENT if friend request already sent or already a friend. + * return FAERR_BADCHECKSUM if bad checksum in address. + * return FAERR_SETNEWNOSPAM if the friend was already there but the nospam was different. + * (the nospam for that friend was set to the new one). + * return FAERR_NOMEM if increasing the friend list size fails. + */ +int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, uint16_t length) +{ + if (length > MAX_FRIEND_REQUEST_DATA_SIZE) { + return FAERR_TOOLONG; + } + + uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE]; + id_copy(real_pk, address); + + if (!public_key_valid(real_pk)) { + return FAERR_BADCHECKSUM; + } + + uint16_t check, checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum)); + memcpy(&check, address + CRYPTO_PUBLIC_KEY_SIZE + sizeof(uint32_t), sizeof(check)); + + if (check != checksum) { + return FAERR_BADCHECKSUM; + } + + if (length < 1) { + return FAERR_NOMESSAGE; + } + + if (id_equal(real_pk, m->net_crypto->self_public_key)) { + return FAERR_OWNKEY; + } + + int32_t friend_id = getfriend_id(m, real_pk); + + if (friend_id != -1) { + if (m->friendlist[friend_id].status >= FRIEND_CONFIRMED) { + return FAERR_ALREADYSENT; + } + + uint32_t nospam; + memcpy(&nospam, address + CRYPTO_PUBLIC_KEY_SIZE, sizeof(nospam)); + + if (m->friendlist[friend_id].friendrequest_nospam == nospam) { + return FAERR_ALREADYSENT; + } + + m->friendlist[friend_id].friendrequest_nospam = nospam; + return FAERR_SETNEWNOSPAM; + } + + int32_t ret = init_new_friend(m, real_pk, FRIEND_ADDED); + + if (ret < 0) { + return ret; + } + + m->friendlist[ret].friendrequest_timeout = FRIENDREQUEST_TIMEOUT; + memcpy(m->friendlist[ret].info, data, length); + m->friendlist[ret].info_size = length; + memcpy(&(m->friendlist[ret].friendrequest_nospam), address + CRYPTO_PUBLIC_KEY_SIZE, sizeof(uint32_t)); + + return ret; +} + +int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk) +{ + if (getfriend_id(m, real_pk) != -1) { + return FAERR_ALREADYSENT; + } + + if (!public_key_valid(real_pk)) { + return FAERR_BADCHECKSUM; + } + + if (id_equal(real_pk, m->net_crypto->self_public_key)) { + return FAERR_OWNKEY; + } + + return init_new_friend(m, real_pk, FRIEND_CONFIRMED); +} + +static int clear_receipts(Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + struct Receipts *receipts = m->friendlist[friendnumber].receipts_start; + + while (receipts) { + struct Receipts *temp_r = receipts->next; + free(receipts); + receipts = temp_r; + } + + m->friendlist[friendnumber].receipts_start = NULL; + m->friendlist[friendnumber].receipts_end = NULL; + return 0; +} + +static int add_receipt(Messenger *m, int32_t friendnumber, uint32_t packet_num, uint32_t msg_id) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + struct Receipts *new_receipts = (struct Receipts *)calloc(1, sizeof(struct Receipts)); + + if (!new_receipts) { + return -1; + } + + new_receipts->packet_num = packet_num; + new_receipts->msg_id = msg_id; + + if (!m->friendlist[friendnumber].receipts_start) { + m->friendlist[friendnumber].receipts_start = new_receipts; + } else { + m->friendlist[friendnumber].receipts_end->next = new_receipts; + } + + m->friendlist[friendnumber].receipts_end = new_receipts; + new_receipts->next = NULL; + return 0; +} +/* + * return -1 on failure. + * return 0 if packet was received. + */ +static int friend_received_packet(const Messenger *m, int32_t friendnumber, uint32_t number) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + return cryptpacket_received(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id), number); +} + +static int do_receipts(Messenger *m, int32_t friendnumber, void *userdata) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + struct Receipts *receipts = m->friendlist[friendnumber].receipts_start; + + while (receipts) { + struct Receipts *temp_r = receipts->next; + + if (friend_received_packet(m, friendnumber, receipts->packet_num) == -1) { + break; + } + + if (m->read_receipt) { + (*m->read_receipt)(m, friendnumber, receipts->msg_id, userdata); + } + + free(receipts); + m->friendlist[friendnumber].receipts_start = temp_r; + receipts = temp_r; + } + + if (!m->friendlist[friendnumber].receipts_start) { + m->friendlist[friendnumber].receipts_end = NULL; + } + + return 0; +} + +/* Remove a friend. + * + * return 0 if success. + * return -1 if failure. + */ +int m_delfriend(Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (m->friend_connectionstatuschange_internal) { + m->friend_connectionstatuschange_internal(m, friendnumber, 0, m->friend_connectionstatuschange_internal_userdata); + } + + clear_receipts(m, friendnumber); + remove_request_received(&(m->fr), m->friendlist[friendnumber].real_pk); + friend_connection_callbacks(m->fr_c, m->friendlist[friendnumber].friendcon_id, MESSENGER_CALLBACK_INDEX, 0, 0, 0, 0, 0); + + if (friend_con_connected(m->fr_c, m->friendlist[friendnumber].friendcon_id) == FRIENDCONN_STATUS_CONNECTED) { + send_offline_packet(m, m->friendlist[friendnumber].friendcon_id); + } + + kill_friend_connection(m->fr_c, m->friendlist[friendnumber].friendcon_id); + memset(&(m->friendlist[friendnumber]), 0, sizeof(Friend)); + uint32_t i; + + for (i = m->numfriends; i != 0; --i) { + if (m->friendlist[i - 1].status != NOFRIEND) { + break; + } + } + + m->numfriends = i; + + if (realloc_friendlist(m, m->numfriends) != 0) { + return FAERR_NOMEM; + } + + return 0; +} + +int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (m->friendlist[friendnumber].status == FRIEND_ONLINE) { + bool direct_connected = 0; + unsigned int num_online_relays = 0; + int crypt_conn_id = friend_connection_crypt_connection_id(m->fr_c, m->friendlist[friendnumber].friendcon_id); + crypto_connection_status(m->net_crypto, crypt_conn_id, &direct_connected, &num_online_relays); + + if (direct_connected) { + return CONNECTION_UDP; + } + + if (num_online_relays) { + return CONNECTION_TCP; + } + + return CONNECTION_UNKNOWN; + } + + return CONNECTION_NONE; +} + +int m_friend_exists(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return 0; + } + + return 1; +} + +/* Send a message of type. + * + * return -1 if friend not valid. + * return -2 if too large. + * return -3 if friend not online. + * return -4 if send failed (because queue is full). + * return -5 if bad type. + * return 0 if success. + */ +int m_send_message_generic(Messenger *m, int32_t friendnumber, uint8_t type, const uint8_t *message, uint32_t length, + uint32_t *message_id) +{ + if (type > MESSAGE_ACTION) { + return -5; + } + + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (length >= MAX_CRYPTO_DATA_SIZE) { + return -2; + } + + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return -3; + } + + VLA(uint8_t, packet, length + 1); + packet[0] = type + PACKET_ID_MESSAGE; + + if (length != 0) { + memcpy(packet + 1, message, length); + } + + int64_t packet_num = write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id), packet, length + 1, 0); + + if (packet_num == -1) { + return -4; + } + + uint32_t msg_id = ++m->friendlist[friendnumber].message_id; + + add_receipt(m, friendnumber, packet_num, msg_id); + + if (message_id) { + *message_id = msg_id; + } + + return 0; +} + +/* Send a name packet to friendnumber. + * length is the length with the NULL terminator. + */ +static int m_sendname(const Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length) +{ + if (length > MAX_NAME_LENGTH) { + return 0; + } + + return write_cryptpacket_id(m, friendnumber, PACKET_ID_NICKNAME, name, length, 0); +} + +/* Set the name and name_length of a friend. + * + * return 0 if success. + * return -1 if failure. + */ +int setfriendname(Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (length > MAX_NAME_LENGTH || length == 0) { + return -1; + } + + m->friendlist[friendnumber].name_length = length; + memcpy(m->friendlist[friendnumber].name, name, length); + return 0; +} + +/* Set our nickname + * name must be a string of maximum MAX_NAME_LENGTH length. + * length must be at least 1 byte. + * length is the length of name with the NULL terminator. + * + * return 0 if success. + * return -1 if failure. + */ +int setname(Messenger *m, const uint8_t *name, uint16_t length) +{ + if (length > MAX_NAME_LENGTH) { + return -1; + } + + if (m->name_length == length && (length == 0 || memcmp(name, m->name, length) == 0)) { + return 0; + } + + if (length) { + memcpy(m->name, name, length); + } + + m->name_length = length; + uint32_t i; + + for (i = 0; i < m->numfriends; ++i) { + m->friendlist[i].name_sent = 0; + } + + return 0; +} + +/* Get our nickname and put it in name. + * name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH bytes. + * + * return the length of the name. + */ +uint16_t getself_name(const Messenger *m, uint8_t *name) +{ + if (name == NULL) { + return 0; + } + + memcpy(name, m->name, m->name_length); + + return m->name_length; +} + +/* Get name of friendnumber and put it in name. + * name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH bytes. + * + * return length of name if success. + * return -1 if failure. + */ +int getname(const Messenger *m, int32_t friendnumber, uint8_t *name) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + memcpy(name, m->friendlist[friendnumber].name, m->friendlist[friendnumber].name_length); + return m->friendlist[friendnumber].name_length; +} + +int m_get_name_size(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + return m->friendlist[friendnumber].name_length; +} + +int m_get_self_name_size(const Messenger *m) +{ + return m->name_length; +} + +int m_set_statusmessage(Messenger *m, const uint8_t *status, uint16_t length) +{ + if (length > MAX_STATUSMESSAGE_LENGTH) { + return -1; + } + + if (m->statusmessage_length == length && (length == 0 || memcmp(m->statusmessage, status, length) == 0)) { + return 0; + } + + if (length) { + memcpy(m->statusmessage, status, length); + } + + m->statusmessage_length = length; + + uint32_t i; + + for (i = 0; i < m->numfriends; ++i) { + m->friendlist[i].statusmessage_sent = 0; + } + + return 0; +} + +int m_set_userstatus(Messenger *m, uint8_t status) +{ + if (status >= USERSTATUS_INVALID) { + return -1; + } + + if (m->userstatus == status) { + return 0; + } + + m->userstatus = (USERSTATUS)status; + uint32_t i; + + for (i = 0; i < m->numfriends; ++i) { + m->friendlist[i].userstatus_sent = 0; + } + + return 0; +} + +/* return the size of friendnumber's user status. + * Guaranteed to be at most MAX_STATUSMESSAGE_LENGTH. + */ +int m_get_statusmessage_size(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + return m->friendlist[friendnumber].statusmessage_length; +} + +/* Copy the user status of friendnumber into buf, truncating if needed to maxlen + * bytes, use m_get_statusmessage_size to find out how much you need to allocate. + */ +int m_copy_statusmessage(const Messenger *m, int32_t friendnumber, uint8_t *buf, uint32_t maxlen) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + int msglen = MIN(maxlen, m->friendlist[friendnumber].statusmessage_length); + + memcpy(buf, m->friendlist[friendnumber].statusmessage, msglen); + memset(buf + msglen, 0, maxlen - msglen); + return msglen; +} + +/* return the size of friendnumber's user status. + * Guaranteed to be at most MAX_STATUSMESSAGE_LENGTH. + */ +int m_get_self_statusmessage_size(const Messenger *m) +{ + return m->statusmessage_length; +} + +int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf) +{ + memcpy(buf, m->statusmessage, m->statusmessage_length); + return m->statusmessage_length; +} + +uint8_t m_get_userstatus(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return USERSTATUS_INVALID; + } + + uint8_t status = m->friendlist[friendnumber].userstatus; + + if (status >= USERSTATUS_INVALID) { + status = USERSTATUS_NONE; + } + + return status; +} + +uint8_t m_get_self_userstatus(const Messenger *m) +{ + return m->userstatus; +} + +uint64_t m_get_last_online(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return UINT64_MAX; + } + + return m->friendlist[friendnumber].last_seen_time; +} + +int m_set_usertyping(Messenger *m, int32_t friendnumber, uint8_t is_typing) +{ + if (is_typing != 0 && is_typing != 1) { + return -1; + } + + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (m->friendlist[friendnumber].user_istyping == is_typing) { + return 0; + } + + m->friendlist[friendnumber].user_istyping = is_typing; + m->friendlist[friendnumber].user_istyping_sent = 0; + + return 0; +} + +int m_get_istyping(const Messenger *m, int32_t friendnumber) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + return m->friendlist[friendnumber].is_typing; +} + +static int send_statusmessage(const Messenger *m, int32_t friendnumber, const uint8_t *status, uint16_t length) +{ + return write_cryptpacket_id(m, friendnumber, PACKET_ID_STATUSMESSAGE, status, length, 0); +} + +static int send_userstatus(const Messenger *m, int32_t friendnumber, uint8_t status) +{ + return write_cryptpacket_id(m, friendnumber, PACKET_ID_USERSTATUS, &status, sizeof(status), 0); +} + +static int send_user_istyping(const Messenger *m, int32_t friendnumber, uint8_t is_typing) +{ + uint8_t typing = is_typing; + return write_cryptpacket_id(m, friendnumber, PACKET_ID_TYPING, &typing, sizeof(typing), 0); +} + +static int set_friend_statusmessage(const Messenger *m, int32_t friendnumber, const uint8_t *status, uint16_t length) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (length > MAX_STATUSMESSAGE_LENGTH) { + return -1; + } + + if (length) { + memcpy(m->friendlist[friendnumber].statusmessage, status, length); + } + + m->friendlist[friendnumber].statusmessage_length = length; + return 0; +} + +static void set_friend_userstatus(const Messenger *m, int32_t friendnumber, uint8_t status) +{ + m->friendlist[friendnumber].userstatus = (USERSTATUS)status; +} + +static void set_friend_typing(const Messenger *m, int32_t friendnumber, uint8_t is_typing) +{ + m->friendlist[friendnumber].is_typing = is_typing; +} + +void m_callback_log(Messenger *m, logger_cb *function, void *context, void *userdata) +{ + logger_callback_log(m->log, function, context, userdata); +} + +/* Set the function that will be executed when a friend request is received. */ +void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const uint8_t *, const uint8_t *, size_t, + void *)) +{ + callback_friendrequest(&(m->fr), (void (*)(void *, const uint8_t *, const uint8_t *, size_t, void *))function, m); +} + +/* Set the function that will be executed when a message from a friend is received. */ +void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, const uint8_t *, + size_t, void *)) +{ + m->friend_message = function; +} + +void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *)) +{ + m->friend_namechange = function; +} + +void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *)) +{ + m->friend_statusmessagechange = function; +} + +void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *)) +{ + m->friend_userstatuschange = function; +} + +void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_t, bool, void *)) +{ + m->friend_typingchange = function; +} + +void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, void *)) +{ + m->read_receipt = function; +} + +void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *)) +{ + m->friend_connectionstatuschange = function; +} + +void m_callback_core_connection(Messenger *m, void (*function)(Messenger *m, unsigned int, void *)) +{ + m->core_connection_change = function; +} + +void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *), + void *userdata) +{ + m->friend_connectionstatuschange_internal = function; + m->friend_connectionstatuschange_internal_userdata = userdata; +} + +static void check_friend_tcp_udp(Messenger *m, int32_t friendnumber, void *userdata) +{ + int last_connection_udp_tcp = m->friendlist[friendnumber].last_connection_udp_tcp; + + int ret = m_get_friend_connectionstatus(m, friendnumber); + + if (ret == -1) { + return; + } + + if (ret == CONNECTION_UNKNOWN) { + if (last_connection_udp_tcp == CONNECTION_UDP) { + return; + } + + ret = CONNECTION_TCP; + } + + if (last_connection_udp_tcp != ret) { + if (m->friend_connectionstatuschange) { + m->friend_connectionstatuschange(m, friendnumber, ret, userdata); + } + } + + m->friendlist[friendnumber].last_connection_udp_tcp = ret; +} + +static void break_files(const Messenger *m, int32_t friendnumber); +static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata) +{ + if (status == NOFRIEND) { + return; + } + + const uint8_t was_online = m->friendlist[friendnumber].status == FRIEND_ONLINE; + const uint8_t is_online = status == FRIEND_ONLINE; + + if (is_online != was_online) { + if (was_online) { + break_files(m, friendnumber); + clear_receipts(m, friendnumber); + } else { + m->friendlist[friendnumber].name_sent = 0; + m->friendlist[friendnumber].userstatus_sent = 0; + m->friendlist[friendnumber].statusmessage_sent = 0; + m->friendlist[friendnumber].user_istyping_sent = 0; + } + + m->friendlist[friendnumber].status = status; + + check_friend_tcp_udp(m, friendnumber, userdata); + + if (m->friend_connectionstatuschange_internal) { + m->friend_connectionstatuschange_internal(m, friendnumber, is_online, + m->friend_connectionstatuschange_internal_userdata); + } + } +} + +void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata) +{ + check_friend_connectionstatus(m, friendnumber, status, userdata); + m->friendlist[friendnumber].status = status; +} + +static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data, + uint32_t length, uint8_t congestion_control) +{ + if (friend_not_valid(m, friendnumber)) { + return 0; + } + + if (length >= MAX_CRYPTO_DATA_SIZE || m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return 0; + } + + VLA(uint8_t, packet, length + 1); + packet[0] = packet_id; + + if (length != 0) { + memcpy(packet + 1, data, length); + } + + return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id), packet, length + 1, congestion_control) != -1; +} + +/**********CONFERENCES************/ + + +/* Set the callback for conference invites. + * + * Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length, void *userdata) + */ +void m_callback_conference_invite(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, + void *)) +{ + m->conference_invite = function; +} + + +/* Send a conference invite packet. + * + * return 1 on success + * return 0 on failure + */ +int send_conference_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length) +{ + return write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_CONFERENCE, data, length, 0); +} + +/****************FILE SENDING*****************/ + + +/* Set the callback for file send requests. + * + * Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint32_t filetype, uint64_t filesize, uint8_t *filename, size_t filename_length, void *userdata) + */ +void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint32_t, uint64_t, + const uint8_t *, size_t, void *)) +{ + m->file_sendrequest = function; +} + +/* Set the callback for file control requests. + * + * Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, unsigned int control_type, void *userdata) + * + */ +void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, unsigned int, void *)) +{ + m->file_filecontrol = function; +} + +/* Set the callback for file data. + * + * Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, uint8_t *data, size_t length, void *userdata) + * + */ +void callback_file_data(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, const uint8_t *, + size_t, void *)) +{ + m->file_filedata = function; +} + +/* Set the callback for file request chunk. + * + * Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, size_t length, void *userdata) + * + */ +void callback_file_reqchunk(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, size_t, void *)) +{ + m->file_reqchunk = function; +} + +#define MAX_FILENAME_LENGTH 255 + +/* Copy the file transfer file id to file_id + * + * return 0 on success. + * return -1 if friend not valid. + * return -2 if filenumber not valid + */ +int file_get_id(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint8_t *file_id) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return -2; + } + + uint32_t temp_filenum; + uint8_t send_receive, file_number; + + if (filenumber >= (1 << 16)) { + send_receive = 1; + temp_filenum = (filenumber >> 16) - 1; + } else { + send_receive = 0; + temp_filenum = filenumber; + } + + if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES) { + return -2; + } + + file_number = temp_filenum; + + struct File_Transfers *ft; + + if (send_receive) { + ft = &m->friendlist[friendnumber].file_receiving[file_number]; + } else { + ft = &m->friendlist[friendnumber].file_sending[file_number]; + } + + if (ft->status == FILESTATUS_NONE) { + return -2; + } + + memcpy(file_id, ft->id, FILE_ID_LENGTH); + return 0; +} + +/* Send a file send request. + * Maximum filename length is 255 bytes. + * return 1 on success + * return 0 on failure + */ +static int file_sendrequest(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint32_t file_type, + uint64_t filesize, const uint8_t *file_id, const uint8_t *filename, uint16_t filename_length) +{ + if (friend_not_valid(m, friendnumber)) { + return 0; + } + + if (filename_length > MAX_FILENAME_LENGTH) { + return 0; + } + + VLA(uint8_t, packet, 1 + sizeof(file_type) + sizeof(filesize) + FILE_ID_LENGTH + filename_length); + packet[0] = filenumber; + file_type = net_htonl(file_type); + memcpy(packet + 1, &file_type, sizeof(file_type)); + host_to_net((uint8_t *)&filesize, sizeof(filesize)); + memcpy(packet + 1 + sizeof(file_type), &filesize, sizeof(filesize)); + memcpy(packet + 1 + sizeof(file_type) + sizeof(filesize), file_id, FILE_ID_LENGTH); + + if (filename_length) { + memcpy(packet + 1 + sizeof(file_type) + sizeof(filesize) + FILE_ID_LENGTH, filename, filename_length); + } + + return write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_SENDREQUEST, packet, SIZEOF_VLA(packet), 0); +} + +/* Send a file send request. + * Maximum filename length is 255 bytes. + * return file number on success + * return -1 if friend not found. + * return -2 if filename length invalid. + * return -3 if no more file sending slots left. + * return -4 if could not send packet (friend offline). + * + */ +long int new_filesender(const Messenger *m, int32_t friendnumber, uint32_t file_type, uint64_t filesize, + const uint8_t *file_id, const uint8_t *filename, uint16_t filename_length) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (filename_length > MAX_FILENAME_LENGTH) { + return -2; + } + + uint32_t i; + + for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) { + if (m->friendlist[friendnumber].file_sending[i].status == FILESTATUS_NONE) { + break; + } + } + + if (i == MAX_CONCURRENT_FILE_PIPES) { + return -3; + } + + if (file_sendrequest(m, friendnumber, i, file_type, filesize, file_id, filename, filename_length) == 0) { + return -4; + } + + struct File_Transfers *ft = &m->friendlist[friendnumber].file_sending[i]; + + ft->status = FILESTATUS_NOT_ACCEPTED; + + ft->size = filesize; + + ft->transferred = 0; + + ft->requested = 0; + + ft->slots_allocated = 0; + + ft->paused = FILE_PAUSE_NOT; + + memcpy(ft->id, file_id, FILE_ID_LENGTH); + + ++m->friendlist[friendnumber].num_sending_files; + + return i; +} + +static int send_file_control_packet(const Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, + uint8_t control_type, uint8_t *data, uint16_t data_length) +{ + if ((unsigned int)(1 + 3 + data_length) > MAX_CRYPTO_DATA_SIZE) { + return -1; + } + + VLA(uint8_t, packet, 3 + data_length); + + packet[0] = send_receive; + packet[1] = filenumber; + packet[2] = control_type; + + if (data_length) { + memcpy(packet + 3, data, data_length); + } + + return write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_CONTROL, packet, SIZEOF_VLA(packet), 0); +} + +/* Send a file control request. + * + * return 0 on success + * return -1 if friend not valid. + * return -2 if friend not online. + * return -3 if file number invalid. + * return -4 if file control is bad. + * return -5 if file already paused. + * return -6 if resume file failed because it was only paused by the other. + * return -7 if resume file failed because it wasn't paused. + * return -8 if packet failed to send. + */ +int file_control(const Messenger *m, int32_t friendnumber, uint32_t filenumber, unsigned int control) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return -2; + } + + uint32_t temp_filenum; + uint8_t send_receive, file_number; + + if (filenumber >= (1 << 16)) { + send_receive = 1; + temp_filenum = (filenumber >> 16) - 1; + } else { + send_receive = 0; + temp_filenum = filenumber; + } + + if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES) { + return -3; + } + + file_number = temp_filenum; + + struct File_Transfers *ft; + + if (send_receive) { + ft = &m->friendlist[friendnumber].file_receiving[file_number]; + } else { + ft = &m->friendlist[friendnumber].file_sending[file_number]; + } + + if (ft->status == FILESTATUS_NONE) { + return -3; + } + + if (control > FILECONTROL_KILL) { + return -4; + } + + if (control == FILECONTROL_PAUSE && ((ft->paused & FILE_PAUSE_US) || ft->status != FILESTATUS_TRANSFERRING)) { + return -5; + } + + if (control == FILECONTROL_ACCEPT) { + if (ft->status == FILESTATUS_TRANSFERRING) { + if (!(ft->paused & FILE_PAUSE_US)) { + if (ft->paused & FILE_PAUSE_OTHER) { + return -6; + } + + return -7; + } + } else { + if (ft->status != FILESTATUS_NOT_ACCEPTED) { + return -7; + } + + if (!send_receive) { + return -6; + } + } + } + + if (send_file_control_packet(m, friendnumber, send_receive, file_number, control, 0, 0)) { + if (control == FILECONTROL_KILL) { + ft->status = FILESTATUS_NONE; + + if (send_receive == 0) { + --m->friendlist[friendnumber].num_sending_files; + } + } else if (control == FILECONTROL_PAUSE) { + ft->paused |= FILE_PAUSE_US; + } else if (control == FILECONTROL_ACCEPT) { + ft->status = FILESTATUS_TRANSFERRING; + + if (ft->paused & FILE_PAUSE_US) { + ft->paused ^= FILE_PAUSE_US; + } + } + } else { + return -8; + } + + return 0; +} + +/* Send a seek file control request. + * + * return 0 on success + * return -1 if friend not valid. + * return -2 if friend not online. + * return -3 if file number invalid. + * return -4 if not receiving file. + * return -5 if file status wrong. + * return -6 if position bad. + * return -8 if packet failed to send. + */ +int file_seek(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint64_t position) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return -2; + } + + if (filenumber < (1 << 16)) { + // Not receiving. + return -4; + } + + uint32_t temp_filenum = (filenumber >> 16) - 1; + + if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES) { + return -3; + } + + assert(temp_filenum <= UINT8_MAX); + uint8_t file_number = temp_filenum; + + // We're always receiving at this point. + struct File_Transfers *ft = &m->friendlist[friendnumber].file_receiving[file_number]; + + if (ft->status == FILESTATUS_NONE) { + return -3; + } + + if (ft->status != FILESTATUS_NOT_ACCEPTED) { + return -5; + } + + if (position >= ft->size) { + return -6; + } + + uint64_t sending_pos = position; + host_to_net((uint8_t *)&sending_pos, sizeof(sending_pos)); + + if (send_file_control_packet(m, friendnumber, 1, file_number, FILECONTROL_SEEK, (uint8_t *)&sending_pos, + sizeof(sending_pos))) { + ft->transferred = position; + } else { + return -8; + } + + return 0; +} + +/* return packet number on success. + * return -1 on failure. + */ +static int64_t send_file_data_packet(const Messenger *m, int32_t friendnumber, uint8_t filenumber, const uint8_t *data, + uint16_t length) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + VLA(uint8_t, packet, 2 + length); + packet[0] = PACKET_ID_FILE_DATA; + packet[1] = filenumber; + + if (length) { + memcpy(packet + 2, data, length); + } + + return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id), packet, SIZEOF_VLA(packet), 1); +} + +#define MAX_FILE_DATA_SIZE (MAX_CRYPTO_DATA_SIZE - 2) +#define MIN_SLOTS_FREE (CRYPTO_MIN_QUEUE_LENGTH / 4) +/* Send file data. + * + * return 0 on success + * return -1 if friend not valid. + * return -2 if friend not online. + * return -3 if filenumber invalid. + * return -4 if file transfer not transferring. + * return -5 if bad data size. + * return -6 if packet queue full. + * return -7 if wrong position. + */ +int file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data, + uint16_t length) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return -2; + } + + if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { + return -3; + } + + struct File_Transfers *ft = &m->friendlist[friendnumber].file_sending[filenumber]; + + if (ft->status != FILESTATUS_TRANSFERRING) { + return -4; + } + + if (length > MAX_FILE_DATA_SIZE) { + return -5; + } + + if (ft->size - ft->transferred < length) { + return -5; + } + + if (ft->size != UINT64_MAX && length != MAX_FILE_DATA_SIZE && (ft->transferred + length) != ft->size) { + return -5; + } + + if (position != ft->transferred || (ft->requested <= position && ft->size != 0)) { + return -7; + } + + /* Prevent file sending from filling up the entire buffer preventing messages from being sent. + * TODO(irungentoo): remove */ + if (crypto_num_free_sendqueue_slots(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id)) < MIN_SLOTS_FREE) { + return -6; + } + + int64_t ret = send_file_data_packet(m, friendnumber, filenumber, data, length); + + if (ret != -1) { + // TODO(irungentoo): record packet ids to check if other received complete file. + ft->transferred += length; + + if (ft->slots_allocated) { + --ft->slots_allocated; + } + + if (length != MAX_FILE_DATA_SIZE || ft->size == ft->transferred) { + ft->status = FILESTATUS_FINISHED; + ft->last_packet_number = ret; + } + + return 0; + } + + return -6; +} + +/* Give the number of bytes left to be sent/received. + * + * send_receive is 0 if we want the sending files, 1 if we want the receiving. + * + * return number of bytes remaining to be sent/received on success + * return 0 on failure + */ +uint64_t file_dataremaining(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive) +{ + if (friend_not_valid(m, friendnumber)) { + return 0; + } + + if (send_receive == 0) { + if (m->friendlist[friendnumber].file_sending[filenumber].status == FILESTATUS_NONE) { + return 0; + } + + return m->friendlist[friendnumber].file_sending[filenumber].size - + m->friendlist[friendnumber].file_sending[filenumber].transferred; + } + + if (m->friendlist[friendnumber].file_receiving[filenumber].status == FILESTATUS_NONE) { + return 0; + } + + return m->friendlist[friendnumber].file_receiving[filenumber].size - + m->friendlist[friendnumber].file_receiving[filenumber].transferred; +} + +static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber, void *userdata) +{ + if (!m->friendlist[friendnumber].num_sending_files) { + return; + } + + int free_slots = crypto_num_free_sendqueue_slots(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id)); + + if (free_slots < MIN_SLOTS_FREE) { + free_slots = 0; + } else { + free_slots -= MIN_SLOTS_FREE; + } + + unsigned int i, num = m->friendlist[friendnumber].num_sending_files; + + for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) { + struct File_Transfers *ft = &m->friendlist[friendnumber].file_sending[i]; + + if (ft->status != FILESTATUS_NONE) { + --num; + + if (ft->status == FILESTATUS_FINISHED) { + /* Check if file was entirely sent. */ + if (friend_received_packet(m, friendnumber, ft->last_packet_number) == 0) { + if (m->file_reqchunk) { + (*m->file_reqchunk)(m, friendnumber, i, ft->transferred, 0, userdata); + } + + ft->status = FILESTATUS_NONE; + --m->friendlist[friendnumber].num_sending_files; + } + } + + /* TODO(irungentoo): if file is too slow, switch to the next. */ + if (ft->slots_allocated > (unsigned int)free_slots) { + free_slots = 0; + } else { + free_slots -= ft->slots_allocated; + } + } + + while (ft->status == FILESTATUS_TRANSFERRING && (ft->paused == FILE_PAUSE_NOT)) { + if (max_speed_reached(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id))) { + free_slots = 0; + } + + if (free_slots == 0) { + break; + } + + uint16_t length = MAX_FILE_DATA_SIZE; + + if (ft->size == 0) { + /* Send 0 data to friend if file is 0 length. */ + file_data(m, friendnumber, i, 0, 0, 0); + break; + } + + if (ft->size == ft->requested) { + break; + } + + if (ft->size - ft->requested < length) { + length = ft->size - ft->requested; + } + + ++ft->slots_allocated; + + uint64_t position = ft->requested; + ft->requested += length; + + if (m->file_reqchunk) { + (*m->file_reqchunk)(m, friendnumber, i, position, length, userdata); + } + + --free_slots; + } + + if (num == 0) { + break; + } + } +} + +/* Run this when the friend disconnects. + * Kill all current file transfers. + */ +static void break_files(const Messenger *m, int32_t friendnumber) +{ + uint32_t i; + + // TODO(irungentoo): Inform the client which file transfers get killed with a callback? + for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) { + if (m->friendlist[friendnumber].file_sending[i].status != FILESTATUS_NONE) { + m->friendlist[friendnumber].file_sending[i].status = FILESTATUS_NONE; + } + + if (m->friendlist[friendnumber].file_receiving[i].status != FILESTATUS_NONE) { + m->friendlist[friendnumber].file_receiving[i].status = FILESTATUS_NONE; + } + } +} + +static struct File_Transfers *get_file_transfer(uint8_t receive_send, uint8_t filenumber, + uint32_t *real_filenumber, Friend *sender) +{ + struct File_Transfers *ft; + + if (receive_send == 0) { + *real_filenumber = (filenumber + 1) << 16; + ft = &sender->file_receiving[filenumber]; + } else { + *real_filenumber = filenumber; + ft = &sender->file_sending[filenumber]; + } + + if (ft->status == FILESTATUS_NONE) { + return NULL; + } + + return ft; +} + +/* return -1 on failure, 0 on success. + */ +static int handle_filecontrol(Messenger *m, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber, + uint8_t control_type, const uint8_t *data, uint16_t length, void *userdata) +{ + if (receive_send > 1) { + LOGGER_DEBUG(m->log, "file control (friend %d, file %d): receive_send value is invalid (should be 0 or 1): %d", + friendnumber, filenumber, receive_send); + return -1; + } + + uint32_t real_filenumber; + struct File_Transfers *ft = get_file_transfer(receive_send, filenumber, &real_filenumber, &m->friendlist[friendnumber]); + + if (ft == NULL) { + LOGGER_DEBUG(m->log, "file control (friend %d, file %d): file transfer does not exist; telling the other to kill it", + friendnumber, filenumber); + send_file_control_packet(m, friendnumber, !receive_send, filenumber, FILECONTROL_KILL, 0, 0); + return -1; + } + + switch (control_type) { + case FILECONTROL_ACCEPT: { + if (receive_send && ft->status == FILESTATUS_NOT_ACCEPTED) { + ft->status = FILESTATUS_TRANSFERRING; + } else { + if (ft->paused & FILE_PAUSE_OTHER) { + ft->paused ^= FILE_PAUSE_OTHER; + } else { + LOGGER_DEBUG(m->log, "file control (friend %d, file %d): friend told us to resume file transfer that wasn't paused", + friendnumber, filenumber); + return -1; + } + } + + if (m->file_filecontrol) { + m->file_filecontrol(m, friendnumber, real_filenumber, control_type, userdata); + } + + return 0; + } + + case FILECONTROL_PAUSE: { + if ((ft->paused & FILE_PAUSE_OTHER) || ft->status != FILESTATUS_TRANSFERRING) { + LOGGER_DEBUG(m->log, "file control (friend %d, file %d): friend told us to pause file transfer that is already paused", + friendnumber, filenumber); + return -1; + } + + ft->paused |= FILE_PAUSE_OTHER; + + if (m->file_filecontrol) { + m->file_filecontrol(m, friendnumber, real_filenumber, control_type, userdata); + } + + return 0; + } + + case FILECONTROL_KILL: { + if (m->file_filecontrol) { + m->file_filecontrol(m, friendnumber, real_filenumber, control_type, userdata); + } + + ft->status = FILESTATUS_NONE; + + if (receive_send) { + --m->friendlist[friendnumber].num_sending_files; + } + + return 0; + } + + case FILECONTROL_SEEK: { + uint64_t position; + + if (length != sizeof(position)) { + LOGGER_DEBUG(m->log, "file control (friend %d, file %d): expected payload of length %d, but got %d", + friendnumber, filenumber, (uint32_t)sizeof(position), length); + return -1; + } + + /* seek can only be sent by the receiver to seek before resuming broken transfers. */ + if (ft->status != FILESTATUS_NOT_ACCEPTED || !receive_send) { + LOGGER_DEBUG(m->log, + "file control (friend %d, file %d): seek was either sent by a sender or by the receiver after accepting", + friendnumber, filenumber); + return -1; + } + + memcpy(&position, data, sizeof(position)); + net_to_host((uint8_t *) &position, sizeof(position)); + + if (position >= ft->size) { + LOGGER_DEBUG(m->log, + "file control (friend %d, file %d): seek position %lld exceeds file size %lld", + friendnumber, filenumber, (unsigned long long)position, (unsigned long long)ft->size); + return -1; + } + + ft->transferred = ft->requested = position; + return 0; + } + + default: { + LOGGER_DEBUG(m->log, "file control (friend %d, file %d): invalid file control: %d", + friendnumber, filenumber, control_type); + return -1; + } + } +} + +/**************************************/ + +/* Set the callback for msi packets. + * + * Function(Messenger *m, int friendnumber, uint8_t *data, uint16_t length, void *userdata) + */ +void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, void *), + void *userdata) +{ + m->msi_packet = function; + m->msi_packet_userdata = userdata; +} + +/* Send an msi packet. + * + * return 1 on success + * return 0 on failure + */ +int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length) +{ + return write_cryptpacket_id(m, friendnumber, PACKET_ID_MSI, data, length, 0); +} + +static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length, + void *userdata) +{ + Messenger *m = (Messenger *)object; + + if (friend_not_valid(m, friend_num)) { + return 1; + } + + if (packet[0] < (PACKET_ID_LOSSY_RANGE_START + PACKET_LOSSY_AV_RESERVED)) { + if (m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % PACKET_LOSSY_AV_RESERVED].function) { + return m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % PACKET_LOSSY_AV_RESERVED].function( + m, friend_num, packet, length, m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % + PACKET_LOSSY_AV_RESERVED].object); + } + + return 1; + } + + if (m->lossy_packethandler) { + m->lossy_packethandler(m, friend_num, packet, length, userdata); + } + + return 1; +} + +void custom_lossy_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m, + uint32_t friendnumber, const uint8_t *data, size_t len, void *object)) +{ + m->lossy_packethandler = packet_handler_callback; +} + +int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int (*packet_handler_callback)(Messenger *m, + uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object), void *object) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (byte < PACKET_ID_LOSSY_RANGE_START) { + return -1; + } + + if (byte >= (PACKET_ID_LOSSY_RANGE_START + PACKET_LOSSY_AV_RESERVED)) { + return -1; + } + + m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].function = + packet_handler_callback; + m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].object = object; + return 0; +} + + +int m_send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (length == 0 || length > MAX_CRYPTO_DATA_SIZE) { + return -2; + } + + if (data[0] < PACKET_ID_LOSSY_RANGE_START) { + return -3; + } + + if (data[0] >= (PACKET_ID_LOSSY_RANGE_START + PACKET_ID_LOSSY_RANGE_SIZE)) { + return -3; + } + + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return -4; + } + + if (send_lossy_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id), data, length) == -1) { + return -5; + } + + return 0; +} + +static int handle_custom_lossless_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length, + void *userdata) +{ + Messenger *m = (Messenger *)object; + + if (friend_not_valid(m, friend_num)) { + return -1; + } + + if (packet[0] < PACKET_ID_LOSSLESS_RANGE_START) { + return -1; + } + + if (packet[0] >= (PACKET_ID_LOSSLESS_RANGE_START + PACKET_ID_LOSSLESS_RANGE_SIZE)) { + return -1; + } + + if (m->lossless_packethandler) { + m->lossless_packethandler(m, friend_num, packet, length, userdata); + } + + return 1; +} + +void custom_lossless_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m, + uint32_t friendnumber, const uint8_t *data, size_t len, void *object)) +{ + m->lossless_packethandler = packet_handler_callback; +} + +int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length) +{ + if (friend_not_valid(m, friendnumber)) { + return -1; + } + + if (length == 0 || length > MAX_CRYPTO_DATA_SIZE) { + return -2; + } + + if (data[0] < PACKET_ID_LOSSLESS_RANGE_START) { + return -3; + } + + if (data[0] >= (PACKET_ID_LOSSLESS_RANGE_START + PACKET_ID_LOSSLESS_RANGE_SIZE)) { + return -3; + } + + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return -4; + } + + if (write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, + m->friendlist[friendnumber].friendcon_id), data, length, 1) == -1) { + return -5; + } + + return 0; +} + +/* Function to filter out some friend requests*/ +static int friend_already_added(const uint8_t *real_pk, void *data) +{ + const Messenger *m = (const Messenger *)data; + + if (getfriend_id(m, real_pk) == -1) { + return 0; + } + + return -1; +} + +/* Run this at startup. */ +Messenger *new_messenger(Messenger_Options *options, unsigned int *error) +{ + if (!options) { + return NULL; + } + + Messenger *m = (Messenger *)calloc(1, sizeof(Messenger)); + + if (error) { + *error = MESSENGER_ERROR_OTHER; + } + + if (!m) { + return NULL; + } + + Logger *log = NULL; + + if (options->log_callback) { + log = logger_new(); + + if (log != NULL) { + logger_callback_log(log, options->log_callback, m, options->log_user_data); + } + } + + m->log = log; + + unsigned int net_err = 0; + + if (options->udp_disabled) { + /* this is the easiest way to completely disable UDP without changing too much code. */ + m->net = (Networking_Core *)calloc(1, sizeof(Networking_Core)); + } else { + IP ip; + ip_init(&ip, options->ipv6enabled); + m->net = new_networking_ex(log, ip, options->port_range[0], options->port_range[1], &net_err); + } + + if (m->net == NULL) { + free(m); + + if (error && net_err == 1) { + *error = MESSENGER_ERROR_PORT; + } + + return NULL; + } + + m->dht = new_DHT(m->log, m->net, options->hole_punching_enabled); + + if (m->dht == NULL) { + kill_networking(m->net); + free(m); + return NULL; + } + + m->net_crypto = new_net_crypto(m->log, m->dht, &options->proxy_info); + + if (m->net_crypto == NULL) { + kill_networking(m->net); + kill_DHT(m->dht); + free(m); + return NULL; + } + + m->onion = new_onion(m->dht); + m->onion_a = new_onion_announce(m->dht); + m->onion_c = new_onion_client(m->net_crypto); + m->fr_c = new_friend_connections(m->onion_c, options->local_discovery_enabled); + + if (!(m->onion && m->onion_a && m->onion_c)) { + kill_friend_connections(m->fr_c); + kill_onion(m->onion); + kill_onion_announce(m->onion_a); + kill_onion_client(m->onion_c); + kill_net_crypto(m->net_crypto); + kill_DHT(m->dht); + kill_networking(m->net); + free(m); + return NULL; + } + + if (options->tcp_server_port) { + m->tcp_server = new_TCP_server(options->ipv6enabled, 1, &options->tcp_server_port, m->dht->self_secret_key, m->onion); + + if (m->tcp_server == NULL) { + kill_friend_connections(m->fr_c); + kill_onion(m->onion); + kill_onion_announce(m->onion_a); + kill_onion_client(m->onion_c); + kill_net_crypto(m->net_crypto); + kill_DHT(m->dht); + kill_networking(m->net); + free(m); + + if (error) { + *error = MESSENGER_ERROR_TCP_SERVER; + } + + return NULL; + } + } + + m->options = *options; + friendreq_init(&(m->fr), m->fr_c); + set_nospam(&(m->fr), random_int()); + set_filter_function(&(m->fr), &friend_already_added, m); + + m->lastdump = 0; + + if (error) { + *error = MESSENGER_ERROR_NONE; + } + + return m; +} + +/* Run this before closing shop. */ +void kill_messenger(Messenger *m) +{ + if (!m) { + return; + } + + uint32_t i; + + if (m->tcp_server) { + kill_TCP_server(m->tcp_server); + } + + kill_friend_connections(m->fr_c); + kill_onion(m->onion); + kill_onion_announce(m->onion_a); + kill_onion_client(m->onion_c); + kill_net_crypto(m->net_crypto); + kill_DHT(m->dht); + kill_networking(m->net); + + for (i = 0; i < m->numfriends; ++i) { + clear_receipts(m, i); + } + + logger_kill(m->log); + free(m->friendlist); + free(m); +} + +/* Check for and handle a timed-out friend request. If the request has + * timed-out then the friend status is set back to FRIEND_ADDED. + * i: friendlist index of the timed-out friend + * t: time + */ +static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t, void *userdata) +{ + Friend *f = &m->friendlist[i]; + + if (f->friendrequest_lastsent + f->friendrequest_timeout < t) { + set_friend_status(m, i, FRIEND_ADDED, userdata); + /* Double the default timeout every time if friendrequest is assumed + * to have been sent unsuccessfully. + */ + f->friendrequest_timeout *= 2; + } +} + +static int m_handle_status(void *object, int i, uint8_t status, void *userdata) +{ + Messenger *m = (Messenger *)object; + + if (status) { /* Went online. */ + send_online_packet(m, i); + } else { /* Went offline. */ + if (m->friendlist[i].status == FRIEND_ONLINE) { + set_friend_status(m, i, FRIEND_CONFIRMED, userdata); + } + } + + return 0; +} + +static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata) +{ + if (len == 0) { + return -1; + } + + Messenger *m = (Messenger *)object; + uint8_t packet_id = temp[0]; + const uint8_t *data = temp + 1; + uint32_t data_length = len - 1; + + if (m->friendlist[i].status != FRIEND_ONLINE) { + if (packet_id == PACKET_ID_ONLINE && len == 1) { + set_friend_status(m, i, FRIEND_ONLINE, userdata); + send_online_packet(m, i); + } else { + return -1; + } + } + + switch (packet_id) { + case PACKET_ID_OFFLINE: { + if (data_length != 0) { + break; + } + + set_friend_status(m, i, FRIEND_CONFIRMED, userdata); + break; + } + + case PACKET_ID_NICKNAME: { + if (data_length > MAX_NAME_LENGTH) { + break; + } + + /* Make sure the NULL terminator is present. */ + VLA(uint8_t, data_terminated, data_length + 1); + memcpy(data_terminated, data, data_length); + data_terminated[data_length] = 0; + + /* inform of namechange before we overwrite the old name */ + if (m->friend_namechange) { + m->friend_namechange(m, i, data_terminated, data_length, userdata); + } + + memcpy(m->friendlist[i].name, data_terminated, data_length); + m->friendlist[i].name_length = data_length; + + break; + } + + case PACKET_ID_STATUSMESSAGE: { + if (data_length > MAX_STATUSMESSAGE_LENGTH) { + break; + } + + /* Make sure the NULL terminator is present. */ + VLA(uint8_t, data_terminated, data_length + 1); + memcpy(data_terminated, data, data_length); + data_terminated[data_length] = 0; + + if (m->friend_statusmessagechange) { + m->friend_statusmessagechange(m, i, data_terminated, data_length, userdata); + } + + set_friend_statusmessage(m, i, data_terminated, data_length); + break; + } + + case PACKET_ID_USERSTATUS: { + if (data_length != 1) { + break; + } + + USERSTATUS status = (USERSTATUS)data[0]; + + if (status >= USERSTATUS_INVALID) { + break; + } + + if (m->friend_userstatuschange) { + m->friend_userstatuschange(m, i, status, userdata); + } + + set_friend_userstatus(m, i, status); + break; + } + + case PACKET_ID_TYPING: { + if (data_length != 1) { + break; + } + + bool typing = !!data[0]; + + set_friend_typing(m, i, typing); + + if (m->friend_typingchange) { + m->friend_typingchange(m, i, typing, userdata); + } + + break; + } + + case PACKET_ID_MESSAGE: // fall-through + case PACKET_ID_ACTION: { + if (data_length == 0) { + break; + } + + const uint8_t *message = data; + uint16_t message_length = data_length; + + /* Make sure the NULL terminator is present. */ + VLA(uint8_t, message_terminated, message_length + 1); + memcpy(message_terminated, message, message_length); + message_terminated[message_length] = 0; + uint8_t type = packet_id - PACKET_ID_MESSAGE; + + if (m->friend_message) { + (*m->friend_message)(m, i, type, message_terminated, message_length, userdata); + } + + break; + } + + case PACKET_ID_INVITE_CONFERENCE: { + if (data_length == 0) { + break; + } + + if (m->conference_invite) { + (*m->conference_invite)(m, i, data, data_length, userdata); + } + + break; + } + + case PACKET_ID_FILE_SENDREQUEST: { + const unsigned int head_length = 1 + sizeof(uint32_t) + sizeof(uint64_t) + FILE_ID_LENGTH; + + if (data_length < head_length) { + break; + } + + uint8_t filenumber = data[0]; + + if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { + break; + } + + uint64_t filesize; + uint32_t file_type; + uint16_t filename_length = data_length - head_length; + + if (filename_length > MAX_FILENAME_LENGTH) { + break; + } + + memcpy(&file_type, data + 1, sizeof(file_type)); + file_type = net_ntohl(file_type); + + memcpy(&filesize, data + 1 + sizeof(uint32_t), sizeof(filesize)); + net_to_host((uint8_t *) &filesize, sizeof(filesize)); + struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber]; + + if (ft->status != FILESTATUS_NONE) { + break; + } + + ft->status = FILESTATUS_NOT_ACCEPTED; + ft->size = filesize; + ft->transferred = 0; + ft->paused = FILE_PAUSE_NOT; + memcpy(ft->id, data + 1 + sizeof(uint32_t) + sizeof(uint64_t), FILE_ID_LENGTH); + + VLA(uint8_t, filename_terminated, filename_length + 1); + uint8_t *filename = NULL; + + if (filename_length) { + /* Force NULL terminate file name. */ + memcpy(filename_terminated, data + head_length, filename_length); + filename_terminated[filename_length] = 0; + filename = filename_terminated; + } + + uint32_t real_filenumber = filenumber; + real_filenumber += 1; + real_filenumber <<= 16; + + if (m->file_sendrequest) { + (*m->file_sendrequest)(m, i, real_filenumber, file_type, filesize, filename, filename_length, + userdata); + } + + break; + } + + case PACKET_ID_FILE_CONTROL: { + if (data_length < 3) { + break; + } + + uint8_t send_receive = data[0]; + uint8_t filenumber = data[1]; + uint8_t control_type = data[2]; + + if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { + break; + } + + if (handle_filecontrol(m, i, send_receive, filenumber, control_type, data + 3, data_length - 3, userdata) == -1) { + // TODO(iphydf): Do something different here? Right now, this + // check is pointless. + break; + } + + break; + } + + case PACKET_ID_FILE_DATA: { + if (data_length < 1) { + break; + } + + uint8_t filenumber = data[0]; + + if (filenumber >= MAX_CONCURRENT_FILE_PIPES) { + break; + } + + struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber]; + + if (ft->status != FILESTATUS_TRANSFERRING) { + break; + } + + uint64_t position = ft->transferred; + uint32_t real_filenumber = filenumber; + real_filenumber += 1; + real_filenumber <<= 16; + uint16_t file_data_length = (data_length - 1); + const uint8_t *file_data; + + if (file_data_length == 0) { + file_data = NULL; + } else { + file_data = data + 1; + } + + /* Prevent more data than the filesize from being passed to clients. */ + if ((ft->transferred + file_data_length) > ft->size) { + file_data_length = ft->size - ft->transferred; + } + + if (m->file_filedata) { + (*m->file_filedata)(m, i, real_filenumber, position, file_data, file_data_length, userdata); + } + + ft->transferred += file_data_length; + + if (file_data_length && (ft->transferred >= ft->size || file_data_length != MAX_FILE_DATA_SIZE)) { + file_data_length = 0; + file_data = NULL; + position = ft->transferred; + + /* Full file received. */ + if (m->file_filedata) { + (*m->file_filedata)(m, i, real_filenumber, position, file_data, file_data_length, userdata); + } + } + + /* Data is zero, filetransfer is over. */ + if (file_data_length == 0) { + ft->status = FILESTATUS_NONE; + } + + break; + } + + case PACKET_ID_MSI: { + if (data_length == 0) { + break; + } + + if (m->msi_packet) { + (*m->msi_packet)(m, i, data, data_length, m->msi_packet_userdata); + } + + break; + } + + default: { + handle_custom_lossless_packet(object, i, temp, len, userdata); + break; + } + } + + return 0; +} + +static void do_friends(Messenger *m, void *userdata) +{ + uint32_t i; + uint64_t temp_time = unix_time(); + + for (i = 0; i < m->numfriends; ++i) { + if (m->friendlist[i].status == FRIEND_ADDED) { + int fr = send_friend_request_packet(m->fr_c, m->friendlist[i].friendcon_id, m->friendlist[i].friendrequest_nospam, + m->friendlist[i].info, + m->friendlist[i].info_size); + + if (fr >= 0) { + set_friend_status(m, i, FRIEND_REQUESTED, userdata); + m->friendlist[i].friendrequest_lastsent = temp_time; + } + } + + if (m->friendlist[i].status == FRIEND_REQUESTED + || m->friendlist[i].status == FRIEND_CONFIRMED) { /* friend is not online. */ + if (m->friendlist[i].status == FRIEND_REQUESTED) { + /* If we didn't connect to friend after successfully sending him a friend request the request is deemed + * unsuccessful so we set the status back to FRIEND_ADDED and try again. + */ + check_friend_request_timed_out(m, i, temp_time, userdata); + } + } + + if (m->friendlist[i].status == FRIEND_ONLINE) { /* friend is online. */ + if (m->friendlist[i].name_sent == 0) { + if (m_sendname(m, i, m->name, m->name_length)) { + m->friendlist[i].name_sent = 1; + } + } + + if (m->friendlist[i].statusmessage_sent == 0) { + if (send_statusmessage(m, i, m->statusmessage, m->statusmessage_length)) { + m->friendlist[i].statusmessage_sent = 1; + } + } + + if (m->friendlist[i].userstatus_sent == 0) { + if (send_userstatus(m, i, m->userstatus)) { + m->friendlist[i].userstatus_sent = 1; + } + } + + if (m->friendlist[i].user_istyping_sent == 0) { + if (send_user_istyping(m, i, m->friendlist[i].user_istyping)) { + m->friendlist[i].user_istyping_sent = 1; + } + } + + check_friend_tcp_udp(m, i, userdata); + do_receipts(m, i, userdata); + do_reqchunk_filecb(m, i, userdata); + + m->friendlist[i].last_seen_time = (uint64_t) time(NULL); + } + } +} + +static void connection_status_cb(Messenger *m, void *userdata) +{ + unsigned int conn_status = onion_connection_status(m->onion_c); + + if (conn_status != m->last_connection_status) { + if (m->core_connection_change) { + (*m->core_connection_change)(m, conn_status, userdata); + } + + m->last_connection_status = conn_status; + } +} + + +#define DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS 60UL + +#define IDSTRING_LEN (CRYPTO_PUBLIC_KEY_SIZE * 2 + 1) +/* id_str should be of length at least IDSTRING_LEN */ +static char *id_to_string(const uint8_t *pk, char *id_str, size_t length) +{ + if (length < IDSTRING_LEN) { + snprintf(id_str, length, "Bad buf length"); + return id_str; + } + + for (uint32_t i = 0; i < CRYPTO_PUBLIC_KEY_SIZE; i++) { + sprintf(&id_str[i * 2], "%02X", pk[i]); + } + + id_str[CRYPTO_PUBLIC_KEY_SIZE * 2] = 0; + return id_str; +} + +/* Minimum messenger run interval in ms + TODO(mannol): A/V */ +#define MIN_RUN_INTERVAL 50 + +/* Return the time in milliseconds before do_messenger() should be called again + * for optimal performance. + * + * returns time (in ms) before the next do_messenger() needs to be run on success. + */ +uint32_t messenger_run_interval(const Messenger *m) +{ + uint32_t crypto_interval = crypto_run_interval(m->net_crypto); + + if (crypto_interval > MIN_RUN_INTERVAL) { + return MIN_RUN_INTERVAL; + } + + return crypto_interval; +} + +/* The main loop that needs to be run at least 20 times per second. */ +void do_messenger(Messenger *m, void *userdata) +{ + // Add the TCP relays, but only if this is the first time calling do_messenger + if (m->has_added_relays == 0) { + m->has_added_relays = 1; + + int i; + + for (i = 0; i < NUM_SAVED_TCP_RELAYS; ++i) { + add_tcp_relay(m->net_crypto, m->loaded_relays[i].ip_port, m->loaded_relays[i].public_key); + } + + if (m->tcp_server) { + /* Add self tcp server. */ + IP_Port local_ip_port; + local_ip_port.port = m->options.tcp_server_port; + local_ip_port.ip.family = TOX_AF_INET; + local_ip_port.ip.ip4 = get_ip4_loopback(); + add_tcp_relay(m->net_crypto, local_ip_port, + tcp_server_public_key(m->tcp_server)); + } + } + + unix_time_update(); + + if (!m->options.udp_disabled) { + networking_poll(m->net, userdata); + do_DHT(m->dht); + } + + if (m->tcp_server) { + do_TCP_server(m->tcp_server); + } + + do_net_crypto(m->net_crypto, userdata); + do_onion_client(m->onion_c); + do_friend_connections(m->fr_c, userdata); + do_friends(m, userdata); + connection_status_cb(m, userdata); + + if (unix_time() > m->lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) { + m->lastdump = unix_time(); + uint32_t client, last_pinged; + + for (client = 0; client < LCLIENT_LIST; client++) { + Client_data *cptr = &m->dht->close_clientlist[client]; + IPPTsPng *assoc = NULL; + uint32_t a; + + for (a = 0, assoc = &cptr->assoc4; a < 2; a++, assoc = &cptr->assoc6) { + if (ip_isset(&assoc->ip_port.ip)) { + last_pinged = m->lastdump - assoc->last_pinged; + + if (last_pinged > 999) { + last_pinged = 999; + } + + char ip_str[IP_NTOA_LEN]; + char id_str[IDSTRING_LEN]; + LOGGER_TRACE(m->log, "C[%2u] %s:%u [%3u] %s", + client, ip_ntoa(&assoc->ip_port.ip, ip_str, sizeof(ip_str)), + net_ntohs(assoc->ip_port.port), last_pinged, + id_to_string(cptr->public_key, id_str, sizeof(id_str))); + } + } + } + + + uint32_t friend_idx, dhtfriend; + + /* dht contains additional "friends" (requests) */ + uint32_t num_dhtfriends = m->dht->num_friends; + VLA(int32_t, m2dht, num_dhtfriends); + VLA(int32_t, dht2m, num_dhtfriends); + + for (friend_idx = 0; friend_idx < num_dhtfriends; friend_idx++) { + m2dht[friend_idx] = -1; + dht2m[friend_idx] = -1; + + if (friend_idx >= m->numfriends) { + continue; + } + + for (dhtfriend = 0; dhtfriend < m->dht->num_friends; dhtfriend++) { + if (id_equal(m->friendlist[friend_idx].real_pk, m->dht->friends_list[dhtfriend].public_key)) { + m2dht[friend_idx] = dhtfriend; + break; + } + } + } + + for (friend_idx = 0; friend_idx < num_dhtfriends; friend_idx++) { + if (m2dht[friend_idx] >= 0) { + dht2m[m2dht[friend_idx]] = friend_idx; + } + } + + if (m->numfriends != m->dht->num_friends) { + LOGGER_TRACE(m->log, "Friend num in DHT %u != friend num in msger %u\n", m->dht->num_friends, m->numfriends); + } + + Friend *msgfptr; + DHT_Friend *dhtfptr; + + for (friend_idx = 0; friend_idx < num_dhtfriends; friend_idx++) { + if (dht2m[friend_idx] >= 0) { + msgfptr = &m->friendlist[dht2m[friend_idx]]; + } else { + msgfptr = NULL; + } + + dhtfptr = &m->dht->friends_list[friend_idx]; + + if (msgfptr) { + char id_str[IDSTRING_LEN]; + LOGGER_TRACE(m->log, "F[%2u:%2u] <%s> %s", + dht2m[friend_idx], friend_idx, msgfptr->name, + id_to_string(msgfptr->real_pk, id_str, sizeof(id_str))); + } else { + char id_str[IDSTRING_LEN]; + LOGGER_TRACE(m->log, "F[--:%2u] %s", friend_idx, + id_to_string(dhtfptr->public_key, id_str, sizeof(id_str))); + } + + for (client = 0; client < MAX_FRIEND_CLIENTS; client++) { + Client_data *cptr = &dhtfptr->client_list[client]; + IPPTsPng *assoc = NULL; + uint32_t a; + + for (a = 0, assoc = &cptr->assoc4; a < 2; a++, assoc = &cptr->assoc6) { + if (ip_isset(&assoc->ip_port.ip)) { + last_pinged = m->lastdump - assoc->last_pinged; + + if (last_pinged > 999) { + last_pinged = 999; + } + + char ip_str[IP_NTOA_LEN]; + char id_str[IDSTRING_LEN]; + LOGGER_TRACE(m->log, "F[%2u] => C[%2u] %s:%u [%3u] %s", + friend_idx, client, ip_ntoa(&assoc->ip_port.ip, ip_str, sizeof(ip_str)), + net_ntohs(assoc->ip_port.port), last_pinged, + id_to_string(cptr->public_key, id_str, sizeof(id_str))); + } + } + } + } + } +} + +/* new messenger format for load/save, more robust and forward compatible */ + +#define MESSENGER_STATE_COOKIE_GLOBAL 0x15ed1b1f + +#define MESSENGER_STATE_COOKIE_TYPE 0x01ce +#define MESSENGER_STATE_TYPE_NOSPAMKEYS 1 +#define MESSENGER_STATE_TYPE_DHT 2 +#define MESSENGER_STATE_TYPE_FRIENDS 3 +#define MESSENGER_STATE_TYPE_NAME 4 +#define MESSENGER_STATE_TYPE_STATUSMESSAGE 5 +#define MESSENGER_STATE_TYPE_STATUS 6 +#define MESSENGER_STATE_TYPE_TCP_RELAY 10 +#define MESSENGER_STATE_TYPE_PATH_NODE 11 +#define MESSENGER_STATE_TYPE_END 255 + +#define SAVED_FRIEND_REQUEST_SIZE 1024 +#define NUM_SAVED_PATH_NODES 8 + +struct SAVED_FRIEND { + uint8_t status; + uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t info[SAVED_FRIEND_REQUEST_SIZE]; // the data that is sent during the friend requests we do. + uint16_t info_size; // Length of the info. + uint8_t name[MAX_NAME_LENGTH]; + uint16_t name_length; + uint8_t statusmessage[MAX_STATUSMESSAGE_LENGTH]; + uint16_t statusmessage_length; + uint8_t userstatus; + uint32_t friendrequest_nospam; + uint64_t last_seen_time; +}; + +static uint32_t friend_size() +{ + uint32_t data = 0; + const struct SAVED_FRIEND temp = { 0 }; + +#define VALUE_MEMBER(NAME) data += sizeof(temp.NAME) +#define ARRAY_MEMBER(NAME) data += sizeof(temp.NAME) + + // Exactly the same in friend_load, friend_save, and friend_size + VALUE_MEMBER(status); + ARRAY_MEMBER(real_pk); + ARRAY_MEMBER(info); + data++; // padding + VALUE_MEMBER(info_size); + ARRAY_MEMBER(name); + VALUE_MEMBER(name_length); + ARRAY_MEMBER(statusmessage); + data++; // padding + VALUE_MEMBER(statusmessage_length); + VALUE_MEMBER(userstatus); + data += 3; // padding + VALUE_MEMBER(friendrequest_nospam); + VALUE_MEMBER(last_seen_time); + +#undef VALUE_MEMBER +#undef ARRAY_MEMBER + + return data; +} + +static uint32_t saved_friendslist_size(const Messenger *m) +{ + return count_friendlist(m) * friend_size(); +} + +static uint8_t *friend_save(const struct SAVED_FRIEND *temp, uint8_t *data) +{ +#define VALUE_MEMBER(NAME) \ + memcpy(data, &temp->NAME, sizeof(temp->NAME)); \ + data += sizeof(temp->NAME) + +#define ARRAY_MEMBER(NAME) \ + memcpy(data, temp->NAME, sizeof(temp->NAME)); \ + data += sizeof(temp->NAME) + + // Exactly the same in friend_load, friend_save, and friend_size + VALUE_MEMBER(status); + ARRAY_MEMBER(real_pk); + ARRAY_MEMBER(info); + data++; // padding + VALUE_MEMBER(info_size); + ARRAY_MEMBER(name); + VALUE_MEMBER(name_length); + ARRAY_MEMBER(statusmessage); + data++; // padding + VALUE_MEMBER(statusmessage_length); + VALUE_MEMBER(userstatus); + data += 3; // padding + VALUE_MEMBER(friendrequest_nospam); + VALUE_MEMBER(last_seen_time); + +#undef VALUE_MEMBER +#undef ARRAY_MEMBER + + return data; +} + +static uint32_t friends_list_save(const Messenger *m, uint8_t *data) +{ + uint32_t i; + uint32_t num = 0; + uint8_t *cur_data = data; + + for (i = 0; i < m->numfriends; i++) { + if (m->friendlist[i].status > 0) { + struct SAVED_FRIEND temp = { 0 }; + temp.status = m->friendlist[i].status; + memcpy(temp.real_pk, m->friendlist[i].real_pk, CRYPTO_PUBLIC_KEY_SIZE); + + if (temp.status < 3) { + const size_t friendrequest_length = + MIN(m->friendlist[i].info_size, + MIN(SAVED_FRIEND_REQUEST_SIZE, MAX_FRIEND_REQUEST_DATA_SIZE)); + memcpy(temp.info, m->friendlist[i].info, friendrequest_length); + + temp.info_size = net_htons(m->friendlist[i].info_size); + temp.friendrequest_nospam = m->friendlist[i].friendrequest_nospam; + } else { + memcpy(temp.name, m->friendlist[i].name, m->friendlist[i].name_length); + temp.name_length = net_htons(m->friendlist[i].name_length); + memcpy(temp.statusmessage, m->friendlist[i].statusmessage, m->friendlist[i].statusmessage_length); + temp.statusmessage_length = net_htons(m->friendlist[i].statusmessage_length); + temp.userstatus = m->friendlist[i].userstatus; + + uint8_t last_seen_time[sizeof(uint64_t)]; + memcpy(last_seen_time, &m->friendlist[i].last_seen_time, sizeof(uint64_t)); + host_to_net(last_seen_time, sizeof(uint64_t)); + memcpy(&temp.last_seen_time, last_seen_time, sizeof(uint64_t)); + } + + uint8_t *next_data = friend_save(&temp, cur_data); + assert(next_data - cur_data == friend_size()); +#ifdef __LP64__ + assert(memcmp(cur_data, &temp, friend_size()) == 0); +#endif + cur_data = next_data; + num++; + } + } + + assert(cur_data - data == num * friend_size()); + return cur_data - data; +} + +static const uint8_t *friend_load(struct SAVED_FRIEND *temp, const uint8_t *data) +{ +#define VALUE_MEMBER(NAME) \ + memcpy(&temp->NAME, data, sizeof(temp->NAME)); \ + data += sizeof(temp->NAME) + +#define ARRAY_MEMBER(NAME) \ + memcpy(temp->NAME, data, sizeof(temp->NAME)); \ + data += sizeof(temp->NAME) + + // Exactly the same in friend_load, friend_save, and friend_size + VALUE_MEMBER(status); + ARRAY_MEMBER(real_pk); + ARRAY_MEMBER(info); + data++; // padding + VALUE_MEMBER(info_size); + ARRAY_MEMBER(name); + VALUE_MEMBER(name_length); + ARRAY_MEMBER(statusmessage); + data++; // padding + VALUE_MEMBER(statusmessage_length); + VALUE_MEMBER(userstatus); + data += 3; // padding + VALUE_MEMBER(friendrequest_nospam); + VALUE_MEMBER(last_seen_time); + +#undef VALUE_MEMBER +#undef ARRAY_MEMBER + + return data; +} + +static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length) +{ + if (length % friend_size() != 0) { + return -1; + } + + uint32_t num = length / friend_size(); + uint32_t i; + const uint8_t *cur_data = data; + + for (i = 0; i < num; ++i) { + struct SAVED_FRIEND temp = { 0 }; + const uint8_t *next_data = friend_load(&temp, cur_data); + assert(next_data - cur_data == friend_size()); +#ifdef __LP64__ + assert(memcmp(&temp, cur_data, friend_size()) == 0); +#endif + cur_data = next_data; + + if (temp.status >= 3) { + int fnum = m_addfriend_norequest(m, temp.real_pk); + + if (fnum < 0) { + continue; + } + + setfriendname(m, fnum, temp.name, net_ntohs(temp.name_length)); + set_friend_statusmessage(m, fnum, temp.statusmessage, net_ntohs(temp.statusmessage_length)); + set_friend_userstatus(m, fnum, temp.userstatus); + uint8_t last_seen_time[sizeof(uint64_t)]; + memcpy(last_seen_time, &temp.last_seen_time, sizeof(uint64_t)); + net_to_host(last_seen_time, sizeof(uint64_t)); + memcpy(&m->friendlist[fnum].last_seen_time, last_seen_time, sizeof(uint64_t)); + } else if (temp.status != 0) { + /* TODO(irungentoo): This is not a good way to do this. */ + uint8_t address[FRIEND_ADDRESS_SIZE]; + id_copy(address, temp.real_pk); + memcpy(address + CRYPTO_PUBLIC_KEY_SIZE, &(temp.friendrequest_nospam), sizeof(uint32_t)); + uint16_t checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum)); + memcpy(address + CRYPTO_PUBLIC_KEY_SIZE + sizeof(uint32_t), &checksum, sizeof(checksum)); + m_addfriend(m, address, temp.info, net_ntohs(temp.info_size)); + } + } + + return num; +} + +/* return size of the messenger data (for saving) */ +uint32_t messenger_size(const Messenger *m) +{ + uint32_t size32 = sizeof(uint32_t), sizesubhead = size32 * 2; + return size32 * 2 // global cookie + + sizesubhead + sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE + + sizesubhead + DHT_size(m->dht) // DHT + + sizesubhead + saved_friendslist_size(m) // Friendlist itself. + + sizesubhead + m->name_length // Own nickname. + + sizesubhead + m->statusmessage_length // status message + + sizesubhead + 1 // status + + sizesubhead + NUM_SAVED_TCP_RELAYS * packed_node_size(TCP_INET6) //TCP relays + + sizesubhead + NUM_SAVED_PATH_NODES * packed_node_size(TCP_INET6) //saved path nodes + + sizesubhead; +} + +static uint8_t *messenger_save_subheader(uint8_t *data, uint32_t len, uint16_t type) +{ + host_to_lendian32(data, len); + data += sizeof(uint32_t); + host_to_lendian32(data, (host_tolendian16(MESSENGER_STATE_COOKIE_TYPE) << 16) | host_tolendian16(type)); + data += sizeof(uint32_t); + return data; +} + +/* Save the messenger in data of size Messenger_size(). */ +void messenger_save(const Messenger *m, uint8_t *data) +{ + memset(data, 0, messenger_size(m)); + + uint32_t len; + uint16_t type; + uint32_t size32 = sizeof(uint32_t); + + memset(data, 0, size32); + data += size32; + host_to_lendian32(data, MESSENGER_STATE_COOKIE_GLOBAL); + data += size32; + + assert(sizeof(get_nospam(&m->fr)) == sizeof(uint32_t)); + len = size32 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE; + type = MESSENGER_STATE_TYPE_NOSPAMKEYS; + data = messenger_save_subheader(data, len, type); + *(uint32_t *)data = get_nospam(&(m->fr)); + save_keys(m->net_crypto, data + size32); + data += len; + + len = saved_friendslist_size(m); + type = MESSENGER_STATE_TYPE_FRIENDS; + data = messenger_save_subheader(data, len, type); + friends_list_save(m, data); + data += len; + + len = m->name_length; + type = MESSENGER_STATE_TYPE_NAME; + data = messenger_save_subheader(data, len, type); + memcpy(data, m->name, len); + data += len; + + len = m->statusmessage_length; + type = MESSENGER_STATE_TYPE_STATUSMESSAGE; + data = messenger_save_subheader(data, len, type); + memcpy(data, m->statusmessage, len); + data += len; + + len = 1; + type = MESSENGER_STATE_TYPE_STATUS; + data = messenger_save_subheader(data, len, type); + *data = m->userstatus; + data += len; + + len = DHT_size(m->dht); + type = MESSENGER_STATE_TYPE_DHT; + data = messenger_save_subheader(data, len, type); + DHT_save(m->dht, data); + data += len; + + Node_format relays[NUM_SAVED_TCP_RELAYS]; + type = MESSENGER_STATE_TYPE_TCP_RELAY; + uint8_t *temp_data = data; + data = messenger_save_subheader(temp_data, 0, type); + unsigned int num = copy_connected_tcp_relays(m->net_crypto, relays, NUM_SAVED_TCP_RELAYS); + int l = pack_nodes(data, NUM_SAVED_TCP_RELAYS * packed_node_size(TCP_INET6), relays, num); + + if (l > 0) { + len = l; + data = messenger_save_subheader(temp_data, len, type); + data += len; + } + + Node_format nodes[NUM_SAVED_PATH_NODES]; + type = MESSENGER_STATE_TYPE_PATH_NODE; + temp_data = data; + data = messenger_save_subheader(data, 0, type); + memset(nodes, 0, sizeof(nodes)); + num = onion_backup_nodes(m->onion_c, nodes, NUM_SAVED_PATH_NODES); + l = pack_nodes(data, NUM_SAVED_PATH_NODES * packed_node_size(TCP_INET6), nodes, num); + + if (l > 0) { + len = l; + data = messenger_save_subheader(temp_data, len, type); + data += len; + } + + messenger_save_subheader(data, 0, MESSENGER_STATE_TYPE_END); +} + +static int messenger_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type) +{ + Messenger *m = (Messenger *)outer; + + switch (type) { + case MESSENGER_STATE_TYPE_NOSPAMKEYS: + if (length == CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE + sizeof(uint32_t)) { + set_nospam(&(m->fr), *(const uint32_t *)data); + load_secret_key(m->net_crypto, (&data[sizeof(uint32_t)]) + CRYPTO_PUBLIC_KEY_SIZE); + + if (public_key_cmp((&data[sizeof(uint32_t)]), m->net_crypto->self_public_key) != 0) { + return -1; + } + } else { + return -1; /* critical */ + } + + break; + + case MESSENGER_STATE_TYPE_DHT: + DHT_load(m->dht, data, length); + break; + + case MESSENGER_STATE_TYPE_FRIENDS: + friends_list_load(m, data, length); + break; + + case MESSENGER_STATE_TYPE_NAME: + if ((length > 0) && (length <= MAX_NAME_LENGTH)) { + setname(m, data, length); + } + + break; + + case MESSENGER_STATE_TYPE_STATUSMESSAGE: + if ((length > 0) && (length <= MAX_STATUSMESSAGE_LENGTH)) { + m_set_statusmessage(m, data, length); + } + + break; + + case MESSENGER_STATE_TYPE_STATUS: + if (length == 1) { + m_set_userstatus(m, *data); + } + + break; + + case MESSENGER_STATE_TYPE_TCP_RELAY: { + if (length == 0) { + break; + } + + unpack_nodes(m->loaded_relays, NUM_SAVED_TCP_RELAYS, 0, data, length, 1); + m->has_added_relays = 0; + + break; + } + + case MESSENGER_STATE_TYPE_PATH_NODE: { + Node_format nodes[NUM_SAVED_PATH_NODES]; + + if (length == 0) { + break; + } + + int i, num = unpack_nodes(nodes, NUM_SAVED_PATH_NODES, 0, data, length, 0); + + for (i = 0; i < num; ++i) { + onion_add_bs_path_node(m->onion_c, nodes[i].ip_port, nodes[i].public_key); + } + + break; + } + + case MESSENGER_STATE_TYPE_END: { + if (length != 0) { + return -1; + } + + return -2; + } + + default: + LOGGER_ERROR(m->log, "Load state: contains unrecognized part (len %u, type %u)\n", + length, type); + break; + } + + return 0; +} + +/* Load the messenger from data of size length. */ +int messenger_load(Messenger *m, const uint8_t *data, uint32_t length) +{ + uint32_t data32[2]; + uint32_t cookie_len = sizeof(data32); + + if (length < cookie_len) { + return -1; + } + + memcpy(data32, data, sizeof(uint32_t)); + lendian_to_host32(data32 + 1, data + sizeof(uint32_t)); + + if (!data32[0] && (data32[1] == MESSENGER_STATE_COOKIE_GLOBAL)) { + return load_state(messenger_load_state_callback, m->log, m, data + cookie_len, + length - cookie_len, MESSENGER_STATE_COOKIE_TYPE); + } + + return -1; +} + +/* Return the number of friends in the instance m. + * You should use this to determine how much memory to allocate + * for copy_friendlist. */ +uint32_t count_friendlist(const Messenger *m) +{ + uint32_t ret = 0; + uint32_t i; + + for (i = 0; i < m->numfriends; i++) { + if (m->friendlist[i].status > 0) { + ret++; + } + } + + return ret; +} + +/* Copy a list of valid friend IDs into the array out_list. + * If out_list is NULL, returns 0. + * Otherwise, returns the number of elements copied. + * If the array was too small, the contents + * of out_list will be truncated to list_size. */ +uint32_t copy_friendlist(Messenger const *m, uint32_t *out_list, uint32_t list_size) +{ + if (!out_list) { + return 0; + } + + if (m->numfriends == 0) { + return 0; + } + + uint32_t i; + uint32_t ret = 0; + + for (i = 0; i < m->numfriends; i++) { + if (ret >= list_size) { + break; /* Abandon ship */ + } + + if (m->friendlist[i].status > 0) { + out_list[ret] = i; + ret++; + } + } + + return ret; +} |