void friend_cleanup(Tox *tox)
{
uint32_t friend_count = tox_self_get_friend_list_size(tox);
if (friend_count == 0) {
return;
}
uint32_t friends[friend_count];
tox_self_get_friend_list(tox, friends);
uint64_t curr_time = time(NULL);
for (uint32_t i = 0; i < friend_count; i++) {
TOX_ERR_FRIEND_GET_LAST_ONLINE err;
uint32_t friend = friends[i];
uint64_t last_online = tox_friend_get_last_online(tox, friend, &err);
if (err != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK) {
printf("couldn't obtain 'last online', this should never happen\n");
continue;
}
if (curr_time - last_online > 2629743) {
printf("removing friend %d\n", friend);
tox_friend_delete(tox, friend, NULL);
}
}
/**
* @brief Returns the list of friendIds in our friendlist, an empty list on error
*/
QVector<uint32_t> Core::getFriendList() const
{
QVector<uint32_t> friends;
friends.resize(tox_self_get_friend_list_size(tox));
tox_self_get_friend_list(tox, friends.data());
return friends;
}
/**
* @brief Checks if we have a friend by public key
*/
bool Core::hasFriendWithPublicKey(const QString &pubkey) const
{
// Valid length check
if (pubkey.length() != (TOX_PUBLIC_KEY_SIZE * 2))
return false;
bool found = false;
const size_t friendCount = tox_self_get_friend_list_size(tox);
if (friendCount > 0)
{
uint32_t *ids = new uint32_t[friendCount];
tox_self_get_friend_list(tox, ids);
for (int32_t i = 0; i < static_cast<int32_t>(friendCount); ++i)
{
// getFriendAddress may return either id (public key) or address
QString addrOrId = getFriendAddress(ids[i]);
// Set true if found
if (addrOrId.toUpper().startsWith(pubkey.toUpper()))
{
found = true;
break;
}
}
delete[] ids;
}
return found;
}
static void purge_inactive_friends(Tox *m)
{
size_t numfriends = tox_self_get_friend_list_size(m);
if (numfriends == 0)
return;
uint32_t friend_list[numfriends];
tox_self_get_friend_list(m, friend_list);
size_t i;
for (i = 0; i < numfriends; ++i) {
uint32_t friendnum = friend_list[i];
if (!tox_friend_exists(m, friendnum))
continue;
TOX_ERR_FRIEND_GET_LAST_ONLINE err;
uint64_t last_online = tox_friend_get_last_online(m, friendnum, &err);
if (err != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK)
continue;
if (((uint64_t) time(NULL)) - last_online > Tox_Bot.inactive_limit)
tox_friend_delete(m, friendnum, NULL);
}
}
static void print_profile_info(Tox *m)
{
printf("ToxBot version %s\n", VERSION);
printf("ID: ");
char address[TOX_ADDRESS_SIZE];
tox_self_get_address(m, (uint8_t *) address);
int i;
for (i = 0; i < TOX_ADDRESS_SIZE; ++i) {
char d[3];
snprintf(d, sizeof(d), "%02X", address[i] & 0xff);
printf("%s", d);
}
printf("\n");
char name[TOX_MAX_NAME_LENGTH];
size_t len = tox_self_get_name_size(m);
tox_self_get_name(m, (uint8_t *) name);
name[len] = '\0';
size_t numfriends = tox_self_get_friend_list_size(m);
printf("Name: %s\n", name);
printf("Contacts: %d\n", (int) numfriends);
printf("Inactive contacts purged after %"PRIu64" days\n", Tox_Bot.inactive_limit / SECONDS_IN_DAY);
}
static void load_friendlist(Tox *m)
{
size_t i;
size_t numfriends = tox_self_get_friend_list_size(m);
for (i = 0; i < numfriends; ++i)
friendlist_onFriendAdded(NULL, m, i, false);
sort_friendlist_index();
}
int utox_avatar_update_friends(Tox *tox){
uint32_t i, friend_count, error_count = 0;
friend_count = tox_self_get_friend_list_size(tox);
uint32_t friend_loop[friend_count];
tox_self_get_friend_list(tox, friend_loop);
for(i = 0; i < friend_count; i++){
if (tox_friend_get_connection_status(tox, friend_loop[i], 0)) {
error_count += !avatar_on_friend_online(tox, friend_loop[i]);
}
}
return error_count;
}
static void cmd_info(Tox *m, uint32_t friendnum, int argc, char (*argv)[MAX_COMMAND_LENGTH])
{
char outmsg[MAX_COMMAND_LENGTH];
char timestr[64];
uint64_t curtime = (uint64_t) time(NULL);
get_elapsed_time_str(timestr, sizeof(timestr), curtime - Tox_Bot.start_time);
snprintf(outmsg, sizeof(outmsg), "Uptime: %s", timestr);
tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);
uint32_t numfriends = tox_self_get_friend_list_size(m);
snprintf(outmsg, sizeof(outmsg), "Friends: %d (%d online)", numfriends, Tox_Bot.num_online_friends);
tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);
snprintf(outmsg, sizeof(outmsg), "Inactive friends are purged after %"PRIu64" days",
Tox_Bot.inactive_limit / SECONDS_IN_DAY);
tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);
/* List active group chats and number of peers in each */
size_t num_chats = tox_conference_get_chatlist_size(m);
if (num_chats == 0) {
tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) "No active groupchats",
strlen("No active groupchats"), NULL);
return;
}
uint32_t groupchat_list[num_chats];
tox_conference_get_chatlist(m, groupchat_list);
uint32_t i;
for (i = 0; i < num_chats; ++i) {
TOX_ERR_CONFERENCE_PEER_QUERY err;
uint32_t groupnum = groupchat_list[i];
uint32_t num_peers = tox_conference_peer_count(m, groupnum, &err);
if (err == TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
int idx = group_index(groupnum);
const char *title = Tox_Bot.g_chats[idx].title_len
? Tox_Bot.g_chats[idx].title : "None";
const char *type = tox_conference_get_type(m, groupnum, NULL) == TOX_CONFERENCE_TYPE_AV ? "Audio" : "Text";
snprintf(outmsg, sizeof(outmsg), "Group %d | %s | peers: %d | Title: %s", groupnum, type,
num_peers, title);
tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);
}
}
}
void Core::loadFriends()
{
const uint32_t friendCount = tox_self_get_friend_list_size(tox);
if (friendCount > 0)
{
// assuming there are not that many friends to fill up the whole stack
uint32_t *ids = new uint32_t[friendCount];
tox_self_get_friend_list(tox, ids);
uint8_t clientId[TOX_PUBLIC_KEY_SIZE];
for (int32_t i = 0; i < static_cast<int32_t>(friendCount); ++i)
{
if (tox_friend_get_public_key(tox, ids[i], clientId, nullptr))
{
emit friendAdded(ids[i], CUserId::toString(clientId));
const size_t nameSize = tox_friend_get_name_size(tox, ids[i], nullptr);
if (nameSize && nameSize != SIZE_MAX)
{
uint8_t *name = new uint8_t[nameSize];
if (tox_friend_get_name(tox, ids[i], name, nullptr))
emit friendUsernameChanged(ids[i], CString::toString(name, nameSize));
delete[] name;
}
const size_t statusMessageSize = tox_friend_get_status_message_size(tox, ids[i], nullptr);
if (statusMessageSize != SIZE_MAX)
{
uint8_t *statusMessage = new uint8_t[statusMessageSize];
if (tox_friend_get_status_message(tox, ids[i], statusMessage, nullptr))
{
emit friendStatusMessageChanged(ids[i], CString::toString(statusMessage, statusMessageSize));
}
delete[] statusMessage;
}
checkLastOnline(ids[i]);
}
}
delete[] ids;
}
}
static void cb_friend_connection_change(Tox *m, uint32_t friendnumber, TOX_CONNECTION connection_status, void *userdata)
{
/* Count the number of online friends.
*
* We have to do this the hard way because our convenient API function to get
* the number of online friends has mysteriously vanished
*/
Tox_Bot.num_online_friends = 0;
size_t i, size = tox_self_get_friend_list_size(m);
if (size == 0)
return;
uint32_t list[size];
tox_self_get_friend_list(m, list);
for (i = 0; i < size; ++i) {
if (tox_friend_get_connection_status(m, list[i], NULL) != TOX_CONNECTION_NONE)
++Tox_Bot.num_online_friends;
}
}
void Core::loadFriends()
{
const uint32_t friendCount = tox_self_get_friend_list_size(tox);
if (friendCount <= 0) {
return;
}
// assuming there are not that many friends to fill up the whole stack
uint32_t* ids = new uint32_t[friendCount];
tox_self_get_friend_list(tox, ids);
uint8_t friendPk[TOX_PUBLIC_KEY_SIZE] = {0x00};
for (uint32_t i = 0; i < friendCount; ++i) {
if (!tox_friend_get_public_key(tox, ids[i], friendPk, nullptr)) {
continue;
}
emit friendAdded(ids[i], ToxPk(friendPk));
GET_FRIEND_PROPERTY(Username, tox_friend_get_name, true);
GET_FRIEND_PROPERTY(StatusMessage, tox_friend_get_status_message, false);
checkLastOnline(ids[i]);
}
delete[] ids;
}
END_TEST
#define NUM_TCP_RELAYS 3
START_TEST(test_many_clients_tcp_b)
{
long long unsigned int cur_time = time(nullptr);
Tox *toxes[NUM_TOXES_TCP];
uint32_t index[NUM_TOXES_TCP];
uint32_t i, j;
uint32_t to_comp = 974536;
for (i = 0; i < NUM_TOXES_TCP; ++i) {
struct Tox_Options *opts = tox_options_new(nullptr);
if (i < NUM_TCP_RELAYS) {
tox_options_set_tcp_port(opts, TCP_RELAY_PORT + i);
} else {
tox_options_set_udp_enabled(opts, 0);
}
index[i] = i + 1;
toxes[i] = tox_new_log(opts, nullptr, &index[i]);
ck_assert_msg(toxes[i] != nullptr, "Failed to create tox instances %u", i);
tox_callback_friend_request(toxes[i], accept_friend_request);
uint8_t dpk[TOX_PUBLIC_KEY_SIZE];
tox_self_get_dht_id(toxes[(i % NUM_TCP_RELAYS)], dpk);
ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, TCP_RELAY_PORT + (i % NUM_TCP_RELAYS), dpk, nullptr),
"add relay error");
tox_self_get_dht_id(toxes[0], dpk);
uint16_t first_port = tox_self_get_udp_port(toxes[0], nullptr);
ck_assert_msg(tox_bootstrap(toxes[i], TOX_LOCALHOST, first_port, dpk, nullptr), "Bootstrap error");
tox_options_free(opts);
}
struct {
uint16_t tox1;
uint16_t tox2;
} pairs[NUM_FRIENDS];
uint8_t address[TOX_ADDRESS_SIZE];
for (i = 0; i < NUM_FRIENDS; ++i) {
loop_top:
pairs[i].tox1 = random_u32() % NUM_TOXES_TCP;
pairs[i].tox2 = (pairs[i].tox1 + random_u32() % (NUM_TOXES_TCP - 1) + 1) % NUM_TOXES_TCP;
for (j = 0; j < i; ++j) {
if (pairs[j].tox2 == pairs[i].tox1 && pairs[j].tox1 == pairs[i].tox2) {
goto loop_top;
}
}
tox_self_get_address(toxes[pairs[i].tox1], address);
TOX_ERR_FRIEND_ADD test;
uint32_t num = tox_friend_add(toxes[pairs[i].tox2], address, (const uint8_t *)"Gentoo", 7, &test);
if (test == TOX_ERR_FRIEND_ADD_ALREADY_SENT) {
goto loop_top;
}
ck_assert_msg(num != UINT32_MAX && test == TOX_ERR_FRIEND_ADD_OK, "Failed to add friend error code: %i", test);
}
uint16_t last_count = 0;
while (1) {
uint16_t counter = 0;
for (i = 0; i < NUM_TOXES_TCP; ++i) {
for (j = 0; j < tox_self_get_friend_list_size(toxes[i]); ++j) {
if (tox_friend_get_connection_status(toxes[i], j, nullptr) == TOX_CONNECTION_TCP) {
++counter;
}
}
}
if (counter != last_count) {
printf("many_clients_tcp_b got to %u\n", counter);
last_count = counter;
}
if (counter == NUM_FRIENDS * 2) {
break;
}
for (i = 0; i < NUM_TOXES_TCP; ++i) {
tox_iterate(toxes[i], &to_comp);
}
c_sleep(30);
}
for (i = 0; i < NUM_TOXES_TCP; ++i) {
tox_kill(toxes[i]);
}
printf("test_many_clients_tcp_b succeeded, took %llu seconds\n", time(nullptr) - cur_time);
}
