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;
}
void setToxCallbacks(Tox* tox, void* userData)
{
tox_callback_friend_request(tox, _friendReqCb, userData);
tox_callback_friend_message(tox, _friendMsgCb, userData);
tox_callback_friend_name (tox, _friendNameCb, userData);
tox_callback_friend_status_message(tox, _friendStatusCb, userData);
tox_callback_friend_status (tox, _friendUserStatusCb, userData);
tox_callback_friend_typing (tox, _friendTypingCb, userData);
tox_callback_friend_read_receipt(tox, _friendReadReceiptCb, userData);
tox_callback_friend_connection_status(tox, _friendConnectionCb, userData);
tox_callback_friend_lossy_packet(tox, _friendLossyPacketCb, userData);
tox_callback_friend_lossless_packet(tox, _friendLosslessPacketCb, userData);
return;
}
static void init_tox_callbacks(Tox *m)
{
tox_callback_self_connection_status(m, prompt_onSelfConnectionChange);
tox_callback_friend_connection_status(m, on_connectionchange);
tox_callback_friend_typing(m, on_typing_change);
tox_callback_friend_request(m, on_request);
tox_callback_friend_message(m, on_message);
tox_callback_friend_name(m, on_nickchange);
tox_callback_friend_status(m, on_statuschange);
tox_callback_friend_status_message(m, on_statusmessagechange);
tox_callback_friend_read_receipt(m, on_read_receipt);
tox_callback_conference_invite(m, on_groupinvite);
tox_callback_conference_message(m, on_groupmessage);
tox_callback_conference_namelist_change(m, on_group_namelistchange);
tox_callback_conference_title(m, on_group_titlechange);
tox_callback_file_recv(m, on_file_recv);
tox_callback_file_chunk_request(m, on_file_chunk_request);
tox_callback_file_recv_control(m, on_file_control);
tox_callback_file_recv_chunk(m, on_file_recv_chunk);
}
void Tox_Dispatcher::init_callbacks()
{
// self callbacks
tox_callback_self_connection_status(tox,
&Tox_Dispatcher::self_connection_status, this);
// friend callbacks
tox_callback_friend_connection_status(tox,
&Tox_Dispatcher::friend_connection_status, this);
tox_callback_friend_lossless_packet(tox,
&Tox_Dispatcher::friend_lossless_packet, this);
tox_callback_friend_lossy_packet(tox,
&Tox_Dispatcher::friend_lossy_packet, this);
tox_callback_friend_message(tox, &Tox_Dispatcher::friend_message, this);
tox_callback_friend_name(tox, &Tox_Dispatcher::friend_name, this);
tox_callback_friend_read_receipt(tox,
&Tox_Dispatcher::friend_read_receipt, this);
tox_callback_friend_request(tox, &Tox_Dispatcher::friend_request, this);
tox_callback_file_recv(tox, Tox_Dispatcher::file_recv, this);
}
static void init_tox_callbacks(Tox *m)
{
tox_callback_self_connection_status(m, prompt_onSelfConnectionChange, NULL);
tox_callback_friend_connection_status(m, on_connectionchange, NULL);
tox_callback_friend_typing(m, on_typing_change, NULL);
tox_callback_friend_request(m, on_request, NULL);
tox_callback_friend_message(m, on_message, NULL);
tox_callback_friend_name(m, on_nickchange, NULL);
tox_callback_friend_status(m, on_statuschange, NULL);
tox_callback_friend_status_message(m, on_statusmessagechange, NULL);
tox_callback_friend_read_receipt(m, on_read_receipt, NULL);
tox_callback_group_invite(m, on_groupinvite, NULL);
tox_callback_group_message(m, on_groupmessage, NULL);
tox_callback_group_action(m, on_groupaction, NULL);
tox_callback_group_namelist_change(m, on_group_namelistchange, NULL);
tox_callback_group_title(m, on_group_titlechange, NULL);
tox_callback_file_recv(m, on_file_recv, NULL);
tox_callback_file_chunk_request(m, on_file_chunk_request, NULL);
tox_callback_file_recv_control(m, on_file_control, NULL);
tox_callback_file_recv_chunk(m, on_file_recv_chunk, NULL);
}
int main(void)
{
setvbuf(stdout, nullptr, _IONBF, 0);
State state1 = {1};
State state2 = {2};
State state3 = {3};
// Create toxes.
Tox *tox1 = tox_new_log(nullptr, nullptr, &state1.id);
Tox *tox2 = tox_new_log(nullptr, nullptr, &state2.id);
Tox *tox3 = tox_new_log(nullptr, nullptr, &state3.id);
// tox1 <-> tox2, tox2 <-> tox3
uint8_t key[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(tox2, key);
tox_friend_add_norequest(tox1, key, nullptr); // tox1 -> tox2
tox_self_get_public_key(tox1, key);
tox_friend_add_norequest(tox2, key, nullptr); // tox2 -> tox1
tox_self_get_public_key(tox3, key);
tox_friend_add_norequest(tox2, key, nullptr); // tox2 -> tox3
tox_self_get_public_key(tox2, key);
tox_friend_add_norequest(tox3, key, nullptr); // tox3 -> tox2
printf("bootstrapping tox2 and tox3 off tox1\n");
uint8_t dht_key[TOX_PUBLIC_KEY_SIZE];
tox_self_get_dht_id(tox1, dht_key);
const uint16_t dht_port = tox_self_get_udp_port(tox1, nullptr);
tox_bootstrap(tox2, "localhost", dht_port, dht_key, nullptr);
tox_bootstrap(tox3, "localhost", dht_port, dht_key, nullptr);
// Connection callbacks.
tox_callback_self_connection_status(tox1, handle_self_connection_status);
tox_callback_self_connection_status(tox2, handle_self_connection_status);
tox_callback_self_connection_status(tox3, handle_self_connection_status);
tox_callback_friend_connection_status(tox1, handle_friend_connection_status);
tox_callback_friend_connection_status(tox2, handle_friend_connection_status);
tox_callback_friend_connection_status(tox3, handle_friend_connection_status);
// Conference callbacks.
tox_callback_conference_invite(tox1, handle_conference_invite);
tox_callback_conference_invite(tox2, handle_conference_invite);
tox_callback_conference_invite(tox3, handle_conference_invite);
tox_callback_conference_connected(tox1, handle_conference_connected);
tox_callback_conference_connected(tox2, handle_conference_connected);
tox_callback_conference_connected(tox3, handle_conference_connected);
tox_callback_conference_message(tox1, handle_conference_message);
tox_callback_conference_message(tox2, handle_conference_message);
tox_callback_conference_message(tox3, handle_conference_message);
tox_callback_conference_peer_list_changed(tox1, handle_conference_peer_list_changed);
tox_callback_conference_peer_list_changed(tox2, handle_conference_peer_list_changed);
tox_callback_conference_peer_list_changed(tox3, handle_conference_peer_list_changed);
// Wait for self connection.
fprintf(stderr, "Waiting for toxes to come online\n");
do {
tox_iterate(tox1, &state1);
tox_iterate(tox2, &state2);
tox_iterate(tox3, &state3);
c_sleep(100);
} while (!state1.self_online || !state2.self_online || !state3.self_online);
fprintf(stderr, "Toxes are online\n");
// Wait for friend connection.
fprintf(stderr, "Waiting for friends to connect\n");
do {
tox_iterate(tox1, &state1);
tox_iterate(tox2, &state2);
tox_iterate(tox3, &state3);
c_sleep(100);
} while (!state1.friend_online || !state2.friend_online || !state3.friend_online);
fprintf(stderr, "Friends are connected\n");
{
// Create new conference, tox1 is the founder.
Tox_Err_Conference_New err;
state1.conference = tox_conference_new(tox1, &err);
state1.joined = true;
ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK, "failed to create a conference: err = %d", err);
fprintf(stderr, "Created conference: id = %u\n", state1.conference);
}
{
// Invite friend.
Tox_Err_Conference_Invite err;
tox_conference_invite(tox1, 0, state1.conference, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK, "failed to invite a friend: err = %d", err);
state1.invited_next = true;
fprintf(stderr, "tox1 invited tox2\n");
}
fprintf(stderr, "Waiting for invitation to arrive\n");
do {
tox_iterate(tox1, &state1);
tox_iterate(tox2, &state2);
tox_iterate(tox3, &state3);
c_sleep(100);
} while (!state1.joined || !state2.joined || !state3.joined);
fprintf(stderr, "Invitations accepted\n");
fprintf(stderr, "Waiting for peers to come online\n");
do {
tox_iterate(tox1, &state1);
tox_iterate(tox2, &state2);
tox_iterate(tox3, &state3);
c_sleep(100);
} while (state1.peers == 0 || state2.peers == 0 || state3.peers == 0);
fprintf(stderr, "All peers are online\n");
{
fprintf(stderr, "tox1 sends a message to the group: \"hello!\"\n");
Tox_Err_Conference_Send_Message err;
tox_conference_send_message(tox1, state1.conference, TOX_MESSAGE_TYPE_NORMAL,
(const uint8_t *)"hello!", 7, &err);
if (err != TOX_ERR_CONFERENCE_SEND_MESSAGE_OK) {
fprintf(stderr, "ERROR: %d\n", err);
exit(EXIT_FAILURE);
}
}
fprintf(stderr, "Waiting for messages to arrive\n");
do {
tox_iterate(tox1, &state1);
tox_iterate(tox2, &state2);
tox_iterate(tox3, &state3);
c_sleep(100);
} while (!state2.received || !state3.received);
fprintf(stderr, "Messages received. Test complete.\n");
tox_kill(tox3);
tox_kill(tox2);
tox_kill(tox1);
return 0;
}
/**
* @brief Initializes the core, must be called before anything else
*/
void Core::start()
{
bool isNewProfile = profile.isNewProfile();
if (isNewProfile)
{
qDebug() << "Creating a new profile";
makeTox(QByteArray());
setStatusMessage(tr("Toxing on qTox"));
setUsername(profile.getName());
}
else
{
qDebug() << "Loading user profile";
QByteArray savedata = profile.loadToxSave();
if (savedata.isEmpty())
{
emit failedToStart();
return;
}
makeTox(savedata);
}
qsrand(time(nullptr));
if (!tox)
{
ready = true;
GUI::setEnabled(true);
return;
}
// set GUI with user and statusmsg
QString name = getUsername();
if (!name.isEmpty())
emit usernameSet(name);
QString msg = getStatusMessage();
if (!msg.isEmpty())
emit statusMessageSet(msg);
QString id = getSelfId().toString();
if (!id.isEmpty())
emit idSet(id);
// TODO: This is a backwards compatibility check,
// once most people have been upgraded away from the old HistoryKeeper, remove this
if (Nexus::getProfile()->isEncrypted())
checkEncryptedHistory();
loadFriends();
tox_callback_friend_request(tox, onFriendRequest, this);
tox_callback_friend_message(tox, onFriendMessage, this);
tox_callback_friend_name(tox, onFriendNameChange, this);
tox_callback_friend_typing(tox, onFriendTypingChange, this);
tox_callback_friend_status_message(tox, onStatusMessageChanged, this);
tox_callback_friend_status(tox, onUserStatusChanged, this);
tox_callback_friend_connection_status(tox, onConnectionStatusChanged, this);
tox_callback_friend_read_receipt(tox, onReadReceiptCallback, this);
tox_callback_group_invite(tox, onGroupInvite, this);
tox_callback_group_message(tox, onGroupMessage, this);
tox_callback_group_namelist_change(tox, onGroupNamelistChange, this);
tox_callback_group_title(tox, onGroupTitleChange, this);
tox_callback_group_action(tox, onGroupAction, this);
tox_callback_file_chunk_request(tox, CoreFile::onFileDataCallback, this);
tox_callback_file_recv(tox, CoreFile::onFileReceiveCallback, this);
tox_callback_file_recv_chunk(tox, CoreFile::onFileRecvChunkCallback, this);
tox_callback_file_recv_control(tox, CoreFile::onFileControlCallback, this);
QPixmap pic = profile.loadAvatar();
if (!pic.isNull() && !pic.size().isEmpty())
{
QByteArray data;
QBuffer buffer(&data);
buffer.open(QIODevice::WriteOnly);
pic.save(&buffer, "PNG");
buffer.close();
setAvatar(data);
}
else
{
qDebug() << "Self avatar not found, will broadcast empty avatar to friends";
setAvatar({});
}
ready = true;
// If we created a new profile earlier,
// now that we're ready save it and ONLY THEN broadcast the new ID.
// This is useful for e.g. the profileForm that searches for saves.
if (isNewProfile)
{
profile.saveToxSave();
emit idSet(getSelfId().toString());
}
if (isReady())
GUI::setEnabled(true);
process(); // starts its own timer
av->start();
}
bool CToxProto::InitToxCore()
{
debugLogA(__FUNCTION__": initializing tox core");
TOX_ERR_OPTIONS_NEW error;
Tox_Options *options = tox_options_new(&error);
if (error != TOX_ERR_OPTIONS_NEW_OK)
{
debugLogA(__FUNCTION__": failed to initialize tox options (%d)", error);
return false;
}
options->udp_enabled = getBool("EnableUDP", 1);
options->ipv6_enabled = getBool("EnableIPv6", 0);
if (hNetlib != NULL)
{
NETLIBUSERSETTINGS nlus = { sizeof(NETLIBUSERSETTINGS) };
CallService(MS_NETLIB_GETUSERSETTINGS, (WPARAM)hNetlib, (LPARAM)&nlus);
if (nlus.useProxy)
{
if (nlus.proxyType == PROXYTYPE_HTTP || nlus.proxyType == PROXYTYPE_HTTPS)
{
debugLogA("CToxProto::InitToxCore: setting http user proxy config");
options->proxy_type = TOX_PROXY_TYPE_HTTP;
mir_strcpy((char*)&options->proxy_host[0], nlus.szProxyServer);
options->proxy_port = nlus.wProxyPort;
}
if (nlus.proxyType == PROXYTYPE_SOCKS4 || nlus.proxyType == PROXYTYPE_SOCKS5)
{
debugLogA("CToxProto::InitToxCore: setting socks user proxy config");
options->proxy_type = TOX_PROXY_TYPE_SOCKS5;
mir_strcpy((char*)&options->proxy_host[0], nlus.szProxyServer);
options->proxy_port = nlus.wProxyPort;
}
}
}
debugLogA(__FUNCTION__": loading tox profile");
if (LoadToxProfile(options))
{
tox_callback_friend_request(tox, OnFriendRequest, this);
tox_callback_friend_message(tox, OnFriendMessage, this);
tox_callback_friend_read_receipt(tox, OnReadReceipt, this);
tox_callback_friend_typing(tox, OnTypingChanged, this);
//
tox_callback_friend_name(tox, OnFriendNameChange, this);
tox_callback_friend_status_message(tox, OnStatusMessageChanged, this);
tox_callback_friend_status(tox, OnUserStatusChanged, this);
tox_callback_friend_connection_status(tox, OnConnectionStatusChanged, this);
// transfers
tox_callback_file_recv_control(tox, OnFileRequest, this);
tox_callback_file_recv(tox, OnFriendFile, this);
tox_callback_file_recv_chunk(tox, OnDataReceiving, this);
tox_callback_file_chunk_request(tox, OnFileSendData, this);
// group chats
//tox_callback_group_invite(tox, OnGroupChatInvite, this);
// a/v
/*toxAv = toxav_new(tox, TOX_MAX_CALLS);
toxav_register_audio_callback(toxAv, OnFriendAudio, this);
toxav_register_callstate_callback(toxAv, OnAvInvite, av_OnInvite, this);
toxav_register_callstate_callback(toxAv, OnAvStart, av_OnStart, this);
toxav_register_callstate_callback(toxAv, OnAvCancel, av_OnCancel, this);
toxav_register_callstate_callback(toxAv, OnAvReject, av_OnReject, this);
toxav_register_callstate_callback(toxAv, OnAvEnd, av_OnEnd, this);
toxav_register_callstate_callback(toxAv, OnAvCallTimeout, av_OnRequestTimeout, this);
toxav_register_callstate_callback(toxAv, OnAvPeerTimeout, av_OnPeerTimeout, this);*/
uint8_t data[TOX_ADDRESS_SIZE];
tox_self_get_address(tox, data);
ToxHexAddress address(data);
setString(TOX_SETTINGS_ID, address);
uint8_t nick[TOX_MAX_NAME_LENGTH] = { 0 };
tox_self_get_name(tox, nick);
setWString("Nick", ptrW(Utf8DecodeW((char*)nick)));
uint8_t statusMessage[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 };
tox_self_get_status_message(tox, statusMessage);
setWString("StatusMsg", ptrW(Utf8DecodeW((char*)statusMessage)));
return true;
}
tox_options_free(options);
return false;
}
/**
* @brief Initializes the core, must be called before anything else
*/
void Core::start(const QByteArray& savedata)
{
bool isNewProfile = profile.isNewProfile();
if (isNewProfile) {
qDebug() << "Creating a new profile";
makeTox(QByteArray());
makeAv();
setStatusMessage(tr("Toxing on qTox"));
setUsername(profile.getName());
} else {
qDebug() << "Loading user profile";
if (savedata.isEmpty()) {
emit failedToStart();
return;
}
makeTox(savedata);
makeAv();
}
qsrand(time(nullptr));
if (!tox) {
ready = true;
GUI::setEnabled(true);
return;
}
// set GUI with user and statusmsg
QString name = getUsername();
if (!name.isEmpty()) {
emit usernameSet(name);
}
QString msg = getStatusMessage();
if (!msg.isEmpty()) {
emit statusMessageSet(msg);
}
ToxId id = getSelfId();
// TODO: probably useless check, comes basically directly from toxcore
if (id.isValid()) {
emit idSet(id);
}
loadFriends();
tox_callback_friend_request(tox, onFriendRequest);
tox_callback_friend_message(tox, onFriendMessage);
tox_callback_friend_name(tox, onFriendNameChange);
tox_callback_friend_typing(tox, onFriendTypingChange);
tox_callback_friend_status_message(tox, onStatusMessageChanged);
tox_callback_friend_status(tox, onUserStatusChanged);
tox_callback_friend_connection_status(tox, onConnectionStatusChanged);
tox_callback_friend_read_receipt(tox, onReadReceiptCallback);
tox_callback_conference_invite(tox, onGroupInvite);
tox_callback_conference_message(tox, onGroupMessage);
tox_callback_conference_namelist_change(tox, onGroupNamelistChange);
tox_callback_conference_title(tox, onGroupTitleChange);
tox_callback_file_chunk_request(tox, CoreFile::onFileDataCallback);
tox_callback_file_recv(tox, CoreFile::onFileReceiveCallback);
tox_callback_file_recv_chunk(tox, CoreFile::onFileRecvChunkCallback);
tox_callback_file_recv_control(tox, CoreFile::onFileControlCallback);
QByteArray data = profile.loadAvatarData(getSelfPublicKey().toString());
if (data.isEmpty()) {
qDebug() << "Self avatar not found, will broadcast empty avatar to friends";
}
setAvatar(data);
ready = true;
if (isNewProfile) {
profile.saveToxSave();
}
if (isReady()) {
GUI::setEnabled(true);
}
process(); // starts its own timer
av->start();
}
void Core::start()
{
qDebug() << "Core: Starting up";
QByteArray savedata = loadToxSave(loadPath);
make_tox(savedata);
// Do we need to create a new save & profile?
if (savedata.isNull())
{
qDebug() << "Save file not found, creating a new profile";
Settings::getInstance().load();
setStatusMessage(tr("Toxing on qTox"));
setUsername(tr("qTox User"));
}
qsrand(time(nullptr));
// set GUI with user and statusmsg
QString name = getUsername();
if (!name.isEmpty())
emit usernameSet(name);
QString msg = getStatusMessage();
if (!msg.isEmpty())
emit statusMessageSet(msg);
QString id = getSelfId().toString();
if (!id.isEmpty())
emit idSet(id);
// tox core is already decrypted
if (Settings::getInstance().getEnableLogging() && Settings::getInstance().getEncryptLogs())
checkEncryptedHistory();
loadFriends();
tox_callback_friend_request(tox, onFriendRequest, this);
tox_callback_friend_message(tox, onFriendMessage, this);
tox_callback_friend_name(tox, onFriendNameChange, this);
tox_callback_friend_typing(tox, onFriendTypingChange, this);
tox_callback_friend_status_message(tox, onStatusMessageChanged, this);
tox_callback_friend_status(tox, onUserStatusChanged, this);
tox_callback_friend_connection_status(tox, onConnectionStatusChanged, this);
tox_callback_friend_read_receipt(tox, onReadReceiptCallback, this);
tox_callback_group_invite(tox, onGroupInvite, this);
tox_callback_group_message(tox, onGroupMessage, this);
tox_callback_group_namelist_change(tox, onGroupNamelistChange, this);
tox_callback_group_title(tox, onGroupTitleChange, this);
tox_callback_group_action(tox, onGroupAction, this);
tox_callback_file_chunk_request(tox, CoreFile::onFileDataCallback, this);
tox_callback_file_recv(tox, CoreFile::onFileReceiveCallback, this);
tox_callback_file_recv_chunk(tox, CoreFile::onFileRecvChunkCallback, this);
tox_callback_file_recv_control(tox, CoreFile::onFileControlCallback, this);
toxav_register_callstate_callback(toxav, onAvInvite, av_OnInvite, this);
toxav_register_callstate_callback(toxav, onAvStart, av_OnStart, this);
toxav_register_callstate_callback(toxav, onAvCancel, av_OnCancel, this);
toxav_register_callstate_callback(toxav, onAvReject, av_OnReject, this);
toxav_register_callstate_callback(toxav, onAvEnd, av_OnEnd, this);
toxav_register_callstate_callback(toxav, onAvRinging, av_OnRinging, this);
toxav_register_callstate_callback(toxav, onAvMediaChange, av_OnPeerCSChange, this);
toxav_register_callstate_callback(toxav, onAvMediaChange, av_OnSelfCSChange, this);
toxav_register_callstate_callback(toxav, onAvRequestTimeout, av_OnRequestTimeout, this);
toxav_register_callstate_callback(toxav, onAvPeerTimeout, av_OnPeerTimeout, this);
toxav_register_audio_callback(toxav, playCallAudio, this);
toxav_register_video_callback(toxav, playCallVideo, this);
QPixmap pic = Settings::getInstance().getSavedAvatar(getSelfId().toString());
if (!pic.isNull() && !pic.size().isEmpty())
{
QByteArray data;
QBuffer buffer(&data);
buffer.open(QIODevice::WriteOnly);
pic.save(&buffer, "PNG");
buffer.close();
setAvatar(data);
}
else
{
qDebug() << "Core: Error loading self avatar";
}
ready = true;
// If we created a new profile earlier,
// now that we're ready save it and ONLY THEN broadcast the new ID.
// This is useful for e.g. the profileForm that searches for saves.
if (savedata.isNull())
{
saveConfiguration();
emit idSet(getSelfId().toString());
}
if (isReady())
GUI::setEnabled(true);
process(); // starts its own timer
}
int main(int argc, char *argv[])
{
uint8_t ipv6enabled = 1; /* x */
int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled);
if (argvoffset < 0) {
exit(1);
}
/* with optional --ipvx, now it can be 1-4 arguments... */
if ((argc != argvoffset + 2) && (argc != argvoffset + 4)) {
printf("Usage: %s [--ipv4|--ipv6] ip port public_key (of the DHT bootstrap node)\n", argv[0]);
exit(0);
}
int *master = (int *)malloc(sizeof(int));
int ret = forkpty(master, NULL, NULL, NULL);
if (ret == -1) {
printf("fork failed\n");
free(master);
return 1;
}
if (ret == 0) {
execl("/bin/sh", "sh", NULL);
return 0;
}
int flags = fcntl(*master, F_GETFL, 0);
int r = fcntl(*master, F_SETFL, flags | O_NONBLOCK);
if (r < 0) {
printf("error setting flags\n");
}
Tox *tox = tox_new(0, 0);
tox_callback_friend_connection_status(tox, print_online);
tox_callback_friend_message(tox, print_message);
uint16_t port = atoi(argv[argvoffset + 2]);
unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]);
int res = tox_bootstrap(tox, argv[argvoffset + 1], port, binary_string, 0);
free(binary_string);
if (!res) {
printf("Failed to convert \"%s\" into an IP address. Exiting...\n", argv[argvoffset + 1]);
exit(1);
}
uint8_t address[TOX_ADDRESS_SIZE];
tox_self_get_address(tox, address);
uint32_t i;
for (i = 0; i < TOX_ADDRESS_SIZE; i++) {
printf("%02X", address[i]);
}
char temp_id[128];
printf("\nEnter the address of the other id you want to sync with (38 bytes HEX format):\n");
if (scanf("%s", temp_id) != 1) {
return 1;
}
uint8_t *bin_id = hex_string_to_bin(temp_id);
uint32_t num = tox_friend_add(tox, bin_id, (const uint8_t *)"Install Gentoo", sizeof("Install Gentoo"), 0);
free(bin_id);
if (num == UINT32_MAX) {
printf("\nSomething went wrong when adding friend.\n");
return 1;
}
uint8_t notconnected = 1;
while (1) {
if (tox_self_get_connection_status(tox) && notconnected) {
printf("\nDHT connected.\n");
notconnected = 0;
}
while (tox_friend_get_connection_status(tox, num, 0)) {
uint8_t buf[TOX_MAX_MESSAGE_LENGTH];
ret = read(*master, buf, sizeof(buf));
if (ret <= 0) {
break;
}
tox_friend_send_message(tox, num, TOX_MESSAGE_TYPE_NORMAL, buf, ret, 0);
}
tox_iterate(tox, master);
c_sleep(1);
}
}
