static Tox *init_tox(void)
{
struct Tox_Options tox_opts;
memset(&tox_opts, 0, sizeof(struct Tox_Options));
tox_options_default(&tox_opts);
Tox *m = load_tox(&tox_opts, DATA_FILE);
if (!m)
return NULL;
tox_callback_self_connection_status(m, cb_self_connection_change, NULL);
tox_callback_friend_connection_status(m, cb_friend_connection_change, NULL);
tox_callback_friend_request(m, cb_friend_request, NULL);
tox_callback_friend_message(m, cb_friend_message, NULL);
tox_callback_group_invite(m, cb_group_invite, NULL);
tox_callback_group_title(m, cb_group_titlechange, NULL);
size_t s_len = tox_self_get_status_message_size(m);
if (s_len == 0) {
const char *statusmsg = "Send me the command 'help' for more info";
tox_self_set_status_message(m, (uint8_t *) statusmsg, strlen(statusmsg), NULL);
}
size_t n_len = tox_self_get_name_size(m);
if (n_len == 0)
tox_self_set_name(m, (uint8_t *) "[LUGNSK]", strlen("[LUGNSK]"), NULL);
return m;
}
static Tox *load_toxic(char *data_path)
{
struct Tox_Options tox_opts;
init_tox_options(&tox_opts);
TOX_ERR_NEW new_err;
Tox *m = load_tox(data_path, &tox_opts, &new_err);
if (new_err == TOX_ERR_NEW_PORT_ALLOC && tox_opts.ipv6_enabled) {
queue_init_message("Falling back to ipv4");
tox_opts.ipv6_enabled = false;
m = load_tox(data_path, &tox_opts, &new_err);
}
if (!m)
exit_toxic_err("tox_new returned fatal error", new_err);
if (new_err != TOX_ERR_NEW_OK)
queue_init_message("tox_new returned non-fatal error %d", new_err);
init_tox_callbacks(m);
load_friendlist(m);
load_blocklist(BLOCK_FILE);
if (tox_self_get_name_size(m) == 0)
tox_self_set_name(m, (uint8_t *) "Toxic User", strlen("Toxic User"), NULL);
return m;
}
void cmd_nick(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
{
if (argc < 1) {
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Input required.");
return;
}
char nick[MAX_STR_SIZE];
size_t len = 0;
if (argv[1][0] == '\"') { /* remove opening and closing quotes */
snprintf(nick, sizeof(nick), "%s", &argv[1][1]);
len = strlen(nick) - 1;
nick[len] = '\0';
} else {
snprintf(nick, sizeof(nick), "%s", argv[1]);
len = strlen(nick);
}
if (!valid_nick(nick)) {
line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid name.");
return;
}
len = MIN(len, TOXIC_MAX_NAME_LENGTH - 1);
nick[len] = '\0';
tox_self_set_name(m, (uint8_t *) nick, len, NULL);
prompt_update_nick(prompt, nick);
store_data(m, DATA_FILE);
}
/* Set username to the machine's FQDN */
void set_tox_username(Tox *tox)
{
char hostname[1024];
TOX_ERR_SET_INFO error;
gethostname((char*)hostname, 1024);
hostname[1023] = '\0';
tox_self_set_name(tox, (uint8_t *)hostname, strlen(hostname), &error);
if(error != TOX_ERR_SET_INFO_OK)
{
log_printf(L_DEBUG, "tox_self_set_name() failed (%u)", error);
}
}
void Core::setUsername(const QString& username)
{
CString cUsername(username);
if (tox_self_set_name(tox, cUsername.data(), cUsername.size(), nullptr) == false)
{
emit failedToSetUsername(username);
}
else
{
emit usernameSet(username);
saveConfiguration();
}
}
INT_PTR CToxProto::SetMyNickname(WPARAM wParam, LPARAM lParam)
{
ptrT nickname((wParam & SMNN_UNICODE) ? mir_u2t((TCHAR*)lParam) : mir_a2t((char*)lParam));
setTString("Nick", nickname);
if (IsOnline())
{
T2Utf szNick8(nickname);
TOX_ERR_SET_INFO error;
if (!tox_self_set_name(toxThread->tox, szNick8, mir_strlen(szNick8), &error))
logger->Log(__FUNCTION__": failed to set nick name");
}
return 0;
}
void Core::setUsername(const QString& username)
{
CString cUsername(username);
if (tox_self_set_name(tox, cUsername.data(), cUsername.size(), nullptr) == false)
{
emit failedToSetUsername(username);
}
else
{
emit usernameSet(username);
if (ready)
profile.saveToxSave();
}
}
/* Set username to the machine's FQDN */
void set_tox_username(Tox *tox)
{
unsigned char hostname[1024];
struct addrinfo hints, *info, *p;
int gai_result;
TOX_ERR_SET_INFO error;
gethostname(hostname, 1024);
hostname[1023] = '\0';
tox_self_set_name(tox, hostname, strlen(hostname), &error);
if(error != TOX_ERR_SET_INFO_OK)
{
log_printf(L_DEBUG, "tox_self_set_name() failed (%u)", error);
}
}
void Core::setUsername(const QString& username)
{
if (username == getUsername())
return;
CString cUsername(username);
if (!tox_self_set_name(tox, cUsername.data(), cUsername.size(), nullptr))
{
emit failedToSetUsername(username);
return;
}
emit usernameSet(username);
if (ready)
profile.saveToxSave();
}
void Tox_Dispatcher::set_self_name(std::string name)
{
if (name.length() > TOX_MAX_NAME_LENGTH) {
LOG(INFO) << "Trimming self name to " << TOX_MAX_NAME_LENGTH
<< " characters";
name = name.substr(0, TOX_MAX_NAME_LENGTH);
}
const size_t len = name.length();
const uint8_t *n = len == 0 ? nullptr :
reinterpret_cast<const uint8_t*>(&name[0]);
TOX_ERR_SET_INFO err;
lock.lock();
if (tox_self_set_name(tox, n, len, &err)) {
save_save_data();
} else {
LOG(WARNING) << "Setting self name failed with error code: "
<< err << "... keeping the old one";
}
lock.unlock();
}
static void cmd_name(Tox *m, uint32_t friendnum, int argc, char (*argv)[MAX_COMMAND_LENGTH])
{
const char *outmsg = NULL;
if (!friend_is_master(m, friendnum)) {
authent_failed(m, friendnum);
return;
}
if (argc < 1) {
outmsg = "Error: Name required";
tox_friend_send_message(m, friendnum, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) outmsg, strlen(outmsg), NULL);
return;
}
char name[TOX_MAX_NAME_LENGTH];
int len = 0;
if (argv[1][0] == '\"') { /* remove opening and closing quotes */
snprintf(name, sizeof(name), "%s", &argv[1][1]);
len = strlen(name) - 1;
} else {
snprintf(name, sizeof(name), "%s", argv[1]);
len = strlen(name);
}
name[len] = '\0';
tox_self_set_name(m, (uint8_t *) name, (uint16_t) len, NULL);
char m_name[TOX_MAX_NAME_LENGTH];
tox_friend_get_name(m, friendnum, (uint8_t *) m_name, NULL);
size_t nlen = tox_friend_get_name_size(m, friendnum, NULL);
m_name[nlen] = '\0';
printf("%s set name to %s\n", m_name, name);
save_data(m, DATA_FILE);
}
static int r2tox_connect() {
if (tox) {
printf ("Status: Online\n");
print_tox_my_address (tox);
return -1;
}
Tox *t = NULL;
struct Tox_Options *options = tox_options_new(NULL);
FILE *fd = fopen("tox.data", "rb");
if (fd) {
eprintf ("Using tox.data\n");
size_t sz = fread (&data, 1, 4096, fd);
fclose (fd);
tox_options_set_savedata_length (options, sz);
tox_options_set_savedata_type (options, TOX_SAVEDATA_TYPE_TOX_SAVE);
tox_options_set_savedata_data (options, data, sz);
t = tox_new (options, NULL);
if (!t) {
printf("cannot new\n");
return 1;
}
} else {
t = tox_new (NULL, NULL);
if (!t) {
eprintf ("cannot new\n");
return 1;
}
// r2tox_save();
}
const char *username = "******";
const char *status = "Available";
tox_self_set_name (t, username, strlen(username), NULL);
tox_self_set_status_message (t, status, strlen(status), NULL);
tox_callback_friend_name(t, handle_friend_name);
tox_callback_friend_request (t, handle_friend_request);
tox_callback_friend_message (t, handle_friend_message);
tox_callback_friend_lossy_packet (t, handle_friend_lossy_packet);
tox_callback_friend_lossless_packet (t, handle_friend_lossless_packet);
tox_callback_friend_read_receipt (t, handle_friend_read_receipt);
tox_callback_conference_invite(t, handle_conference_invite);
tox_callback_conference_message(t, handle_conference_message);
tox_callback_conference_title(t, handle_conference_title);
// bootstrap
size_t i;
for (i = 0; i < sizeof(nodes)/sizeof(DHT_node); i ++) {
sodium_hex2bin(nodes[i].key_bin, sizeof(nodes[i].key_bin),
nodes[i].key_hex, sizeof(nodes[i].key_hex)-1, NULL, NULL, NULL);
tox_bootstrap(t, nodes[i].ip, nodes[i].port, nodes[i].key_bin, NULL);
}
print_tox_my_address (t);
tox_callback_self_connection_status (t, self_connection_status_cb);
tox = t;
// thread here
if (!thread) {
thread = r_th_new (r2tox_mainloop, NULL, 1);
r_th_start (thread, true);
}
return 0;
}
static void test_one(void)
{
uint8_t name[TOX_MAX_NAME_LENGTH];
uint8_t status_message[TOX_MAX_STATUS_MESSAGE_LENGTH];
uint8_t name2[TOX_MAX_NAME_LENGTH];
uint8_t status_message2[TOX_MAX_STATUS_MESSAGE_LENGTH];
uint32_t index[] = { 1, 2 };
Tox *tox1 = tox_new_log(nullptr, nullptr, &index[0]);
set_random_name_and_status_message(tox1, name, status_message);
Tox *tox2 = tox_new_log(nullptr, nullptr, &index[1]);
set_random_name_and_status_message(tox2, name2, status_message2);
uint8_t address[TOX_ADDRESS_SIZE];
tox_self_get_address(tox1, address);
Tox_Err_Friend_Add error;
uint32_t ret = tox_friend_add(tox1, address, (const uint8_t *)"m", 1, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_OWN_KEY, "Adding own address worked.");
tox_self_get_address(tox2, address);
uint8_t message[TOX_MAX_FRIEND_REQUEST_LENGTH + 1];
ret = tox_friend_add(tox1, address, nullptr, 0, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_NULL, "Sending request with no message worked.");
ret = tox_friend_add(tox1, address, message, 0, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_NO_MESSAGE, "Sending request with no message worked.");
ret = tox_friend_add(tox1, address, message, sizeof(message), &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_TOO_LONG,
"TOX_MAX_FRIEND_REQUEST_LENGTH is too big.");
address[0]++;
ret = tox_friend_add(tox1, address, (const uint8_t *)"m", 1, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_BAD_CHECKSUM,
"Adding address with bad checksum worked.");
tox_self_get_address(tox2, address);
ret = tox_friend_add(tox1, address, message, TOX_MAX_FRIEND_REQUEST_LENGTH, &error);
ck_assert_msg(ret == 0 && error == TOX_ERR_FRIEND_ADD_OK, "Failed to add friend.");
ret = tox_friend_add(tox1, address, message, TOX_MAX_FRIEND_REQUEST_LENGTH, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_ALREADY_SENT, "Adding friend twice worked.");
tox_self_set_name(tox1, name, sizeof(name), nullptr);
ck_assert_msg(tox_self_get_name_size(tox1) == sizeof(name), "Can't set name of TOX_MAX_NAME_LENGTH");
tox_self_set_status_message(tox1, status_message, sizeof(status_message), nullptr);
ck_assert_msg(tox_self_get_status_message_size(tox1) == sizeof(status_message),
"Can't set status message of TOX_MAX_STATUS_MESSAGE_LENGTH");
tox_self_get_address(tox1, address);
size_t save_size = tox_get_savedata_size(tox1);
VLA(uint8_t, data, save_size);
tox_get_savedata(tox1, data);
tox_kill(tox2);
Tox_Err_New err_n;
struct Tox_Options *options = tox_options_new(nullptr);
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);
tox_options_set_savedata_data(options, data, save_size);
tox2 = tox_new_log(options, &err_n, &index[1]);
ck_assert_msg(err_n == TOX_ERR_NEW_OK, "Load failed");
ck_assert_msg(tox_self_get_name_size(tox2) == sizeof name, "Wrong name size.");
ck_assert_msg(tox_self_get_status_message_size(tox2) == sizeof status_message, "Wrong status message size");
uint8_t name_loaded[TOX_MAX_NAME_LENGTH] = { 0 };
tox_self_get_name(tox2, name_loaded);
ck_assert_msg(!memcmp(name, name_loaded, sizeof name), "Wrong name.");
uint8_t status_message_loaded[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 };
tox_self_get_status_message(tox2, status_message_loaded);
ck_assert_msg(!memcmp(status_message, status_message_loaded, sizeof status_message_loaded), "Wrong status message.");
uint8_t address2[TOX_ADDRESS_SIZE] = { 0 };
tox_self_get_address(tox2, address2);
ck_assert_msg(memcmp(address2, address, TOX_ADDRESS_SIZE) == 0, "Wrong address.");
uint8_t new_name[TOX_MAX_NAME_LENGTH] = { 0 };
tox_self_get_name(tox2, new_name);
ck_assert_msg(memcmp(name, new_name, TOX_MAX_NAME_LENGTH) == 0, "Wrong name");
uint8_t sk[TOX_SECRET_KEY_SIZE];
tox_self_get_secret_key(tox2, sk);
tox_kill(tox2);
tox_options_default(options);
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_SECRET_KEY);
tox_options_set_savedata_data(options, sk, sizeof(sk));
tox2 = tox_new_log(options, &err_n, &index[1]);
ck_assert_msg(err_n == TOX_ERR_NEW_OK, "Load failed");
uint8_t address3[TOX_ADDRESS_SIZE];
tox_self_get_address(tox2, address3);
ck_assert_msg(memcmp(address3, address, TOX_PUBLIC_KEY_SIZE) == 0, "Wrong public key.");
uint8_t pk[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(tox2, pk);
ck_assert_msg(memcmp(pk, address, TOX_PUBLIC_KEY_SIZE) == 0, "Wrong public key.");
tox_options_free(options);
tox_kill(tox1);
tox_kill(tox2);
}
