ffi-tox 0.1.1 → 0.1.3

data/ProjectTox-Core/testing/misc_tools.c

@@ -1,5 +1,5 @@
 /* misc_tools.c
- * 
+ *
  * Miscellaneous functions and data structures for doing random things.
  *
  *  Copyright (C) 2013 Tox project All Rights Reserved.
@@ -18,23 +18,69 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
- *  
+ *
  */
- 
-#include "misc_tools.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
 
 #include <string.h>
 #include <stdlib.h>
-#include <stdio.h> /* for sscanf */
+#include <stdio.h>
+#include <stdint.h>
+
+#ifdef DEBUG
+#include <assert.h>
+#endif // DEBUG
 
-/* TODO: rewrite */
-unsigned char * hex_string_to_bin(char hex_string[])
+// You are responsible for freeing the return value!
+uint8_t *hex_string_to_bin(char *hex_string)
 {
-    size_t len = strlen(hex_string);
-    unsigned char *val = malloc(len);
+    // byte is represented by exactly 2 hex digits, so lenth of binary string
+    // is half of that of the hex one. only hex string with even length
+    // valid. the more proper implementation would be to check if strlen(hex_string)
+    // is odd and return error code if it is. we assume strlen is even. if it's not
+    // then the last byte just won't be written in 'ret'.
+    size_t i, len = strlen(hex_string) / 2;
+    uint8_t *ret = malloc(len);
     char *pos = hex_string;
-    int i;
-    for(i = 0; i < len; ++i, pos+=2)
-        sscanf(pos,"%2hhx",&val[i]);
-    return val;
+
+    for (i = 0; i < len; ++i, pos += 2)
+        sscanf(pos, "%2hhx", &ret[i]);
+
+    return ret;
 }
+
+int cmdline_parsefor_ipv46(int argc, char **argv, uint8_t *ipv6enabled)
+{
+    int argvoffset = 0, argi;
+
+    for (argi = 1; argi < argc; argi++)
+        if (!strncasecmp(argv[argi], "--ipv", 5)) {
+            if (argv[argi][5] && !argv[argi][6]) {
+                char c = argv[argi][5];
+
+                if (c == '4')
+                    *ipv6enabled = 0;
+                else if (c == '6')
+                    *ipv6enabled = 1;
+                else {
+                    printf("Invalid argument: %s. Try --ipv4 or --ipv6!\n", argv[argi]);
+                    return -1;
+                }
+            } else {
+                printf("Invalid argument: %s. Try --ipv4 or --ipv6!\n", argv[argi]);
+                return -1;
+            }
+
+            if (argvoffset != argi - 1) {
+                printf("Argument must come first: %s.\n", argv[argi]);
+                return -1;
+            }
+
+            argvoffset++;
+        }
+
+    return argvoffset;
+};

data/ProjectTox-Core/testing/nTox.c

@@ -18,15 +18,34 @@
  *
  *  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
+
+#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#define _WIN32_WINNT 0x501
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/types.h>
+#include <netdb.h>
+#endif
+
+#include <sys/select.h>
+
 #include "nTox.h"
-#include "misc_tools.h"
+#include "misc_tools.c"
 
 #include <stdio.h>
 #include <time.h>
+#include <locale.h>
 
-#ifdef WIN32
+#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
 #define c_sleep(x) Sleep(1*x)
 #else
 #include <unistd.h>
@@ -34,429 +53,1273 @@
 #endif
 
 char lines[HISTORY][STRING_LENGTH];
-char line[STRING_LENGTH];
+uint8_t flag[HISTORY];
+char input_line[STRING_LENGTH];
+
+/* wrap: continuation mark */
+const size_t wrap_cont_len = 3;
+const char wrap_cont_str[] = "\n+ ";
+
+#define STRING_LENGTH_WRAPPED (STRING_LENGTH + 16 * (wrap_cont_len + 1))
+
+/* documented: fdmnlsahxgiztq(c[rfg]) */
+/* undocumented: d (tox_do()) */
+
+/* 251+1 characters */
+char *help_main =
+    "[i] Available main commands:\n+ "
+    "/x (to print one's own id)|"
+    "/s status (to change status, e.g. AFK)|"
+    "/n nick (to change your nickname)|"
+    "/q (to quit)|"
+    "/cr (to reset conversation)|"
+    "/h friend (for friend related commands)|"
+    "/h group (for group related commands)";
+
+/* 190+1 characters */
+char *help_friend1 =
+    "[i] Available friend commands (1/2):\n+ "
+    "/l list (to list friends)|"
+    "/r friend no. (to remove from the friend list)|"
+    "/f ID (to send a friend request)|"
+    "/a request no. (to accept a friend request)";
+
+/* 187+1 characters */
+char *help_friend2 =
+    "[i] Available friend commands (2/2):\n+ "
+    "/m friend no. message (to send a message)|"
+    "/t friend no. filename (to send a file to a friend)|"
+    "/cf friend no. (to talk to that friend per default)";
+
+/* 253+1 characters */
+char *help_group =
+    "[i] Available group commands:\n+ "
+    "/g (to create a group)|"
+    "/i friend no. group no. (to invite a friend to a group)|"
+    "/z group no. message (to send a message to a group)|"
+    "/p group no. (to list a group's peers)|"
+    "/cg group no. (to talk to that group per default)";
 
-char *help = "[i] commands: /f ID (to add friend), /m friendnumber message  (to send message), /s status (to change status)\n"
-             "[i] /l list (list friends), /h for help, /i for info, /n nick (to change nickname), /q (to quit)";
 int x, y;
 
+int conversation_default = 0;
+
+typedef struct {
+    uint8_t id[TOX_CLIENT_ID_SIZE];
+    uint8_t accepted;
+} Friend_request;
 
-uint8_t pending_requests[256][CLIENT_ID_SIZE];
+Friend_request pending_requests[256];
 uint8_t num_requests = 0;
 
-void new_lines(char *line)
+#define NUM_FILE_SENDERS 256
+typedef struct {
+    FILE *file;
+    uint16_t friendnum;
+    uint8_t filenumber;
+    uint8_t nextpiece[1024];
+    uint16_t piecelength;
+} File_Sender;
+File_Sender file_senders[NUM_FILE_SENDERS];
+uint8_t numfilesenders;
+
+void send_filesenders(Tox *m)
 {
-    int i;
-    for (i = HISTORY-1; i > 0; i--) 
-        strcpy(lines[i], lines[i-1]);
-    
-    strcpy(lines[0], line);
+    uint32_t i;
+
+    for (i = 0; i < NUM_FILE_SENDERS; ++i) {
+        if (file_senders[i].file == 0)
+            continue;
+
+        while (1) {
+            if (tox_file_send_data(m, file_senders[i].friendnum, file_senders[i].filenumber, file_senders[i].nextpiece,
+                                   file_senders[i].piecelength) == -1)
+                break;
+
+            file_senders[i].piecelength = fread(file_senders[i].nextpiece, 1, tox_file_data_size(m, file_senders[i].friendnum),
+                                                file_senders[i].file);
+
+            if (file_senders[i].piecelength == 0) {
+                fclose(file_senders[i].file);
+                file_senders[i].file = 0;
+                tox_file_send_control(m, file_senders[i].friendnum, 0, file_senders[i].filenumber, 3, 0, 0);
+                char msg[512];
+                sprintf(msg, "[t] %u file transfer: %u completed", file_senders[i].friendnum, file_senders[i].filenumber);
+                new_lines(msg);
+                break;
+            }
+        }
+    }
+}
+int add_filesender(Tox *m, uint16_t friendnum, char *filename)
+{
+    FILE *tempfile = fopen(filename, "r");
+
+    if (tempfile == 0)
+        return -1;
+
+    fseek(tempfile, 0, SEEK_END);
+    uint64_t filesize = ftell(tempfile);
+    fseek(tempfile, 0, SEEK_SET);
+    int filenum = tox_new_file_sender(m, friendnum, filesize, (uint8_t *)filename, strlen(filename) + 1);
+
+    if (filenum == -1)
+        return -1;
+
+    file_senders[numfilesenders].file = tempfile;
+    file_senders[numfilesenders].piecelength = fread(file_senders[numfilesenders].nextpiece, 1, tox_file_data_size(m,
+            file_senders[numfilesenders].friendnum),
+            file_senders[numfilesenders].file);
+    file_senders[numfilesenders].friendnum = friendnum;
+    file_senders[numfilesenders].filenumber = filenum;
+    ++numfilesenders;
+    return filenum;
+}
+
+
+
+#define FRADDR_TOSTR_CHUNK_LEN 8
+#define FRADDR_TOSTR_BUFSIZE (TOX_FRIEND_ADDRESS_SIZE * 2 + TOX_FRIEND_ADDRESS_SIZE / FRADDR_TOSTR_CHUNK_LEN + 1)
+
+static void fraddr_to_str(uint8_t *id_bin, char *id_str)
+{
+    uint32_t i, delta = 0, pos_extra, sum_extra = 0;
+
+    for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; i++) {
+        sprintf(&id_str[2 * i + delta], "%02hhX", id_bin[i]);
+
+        if ((i + 1) == TOX_CLIENT_ID_SIZE)
+            pos_extra = 2 * (i + 1) + delta;
+
+        if (i >= TOX_CLIENT_ID_SIZE)
+            sum_extra |= id_bin[i];
+
+        if (!((i + 1) % FRADDR_TOSTR_CHUNK_LEN)) {
+            id_str[2 * (i + 1) + delta] = ' ';
+            delta++;
+        }
+    }
+
+    id_str[2 * i + delta] = 0;
+
+    if (!sum_extra)
+        id_str[pos_extra] = 0;
+}
+
+void get_id(Tox *m, char *data)
+{
+    sprintf(data, "[i] ID: ");
+    int offset = strlen(data);
+    uint8_t address[TOX_FRIEND_ADDRESS_SIZE];
+    tox_get_address(m, address);
+    fraddr_to_str(address, data + offset);
+}
+
+int getfriendname_terminated(Tox *m, int friendnum, char *namebuf)
+{
+    int res = tox_get_name(m, friendnum, (uint8_t *)namebuf);
+
+    if (res >= 0)
+        namebuf[res] = 0;
+    else
+        namebuf[0] = 0;
+
+    return res;
+}
+
+void new_lines_mark(char *line, uint8_t special)
+{
+    int i = 0;
+
+    for (i = HISTORY - 1; i > 0; i--) {
+        strncpy(lines[i], lines[i - 1], STRING_LENGTH - 1);
+        flag[i] = flag[i - 1];
+    }
+
+    strncpy(lines[0], line, STRING_LENGTH - 1);
+    flag[i] = special;
+
     do_refresh();
 }
 
+void new_lines(char *line)
+{
+    new_lines_mark(line, 0);
+}
+
 
-void print_friendlist()
+const char ptrn_friend[] = "[i] Friend %i: %s\n+ id: %s";
+const int id_str_len = TOX_FRIEND_ADDRESS_SIZE * 2 + 3;
+void print_friendlist(Tox *m)
 {
-    char name[MAX_NAME_LENGTH];
     new_lines("[i] Friend List:");
-    uint32_t i;
-    for (i = 0; i <= num_requests; i++) {
-        char fstring[128];
-        getname(i, (uint8_t*)name);
+
+    char name[TOX_MAX_NAME_LENGTH + 1];
+    uint8_t fraddr_bin[TOX_FRIEND_ADDRESS_SIZE];
+    char fraddr_str[FRADDR_TOSTR_BUFSIZE];
+
+    /* account for the longest name and the longest "base" string and number (int) and id_str */
+    char fstring[TOX_MAX_NAME_LENGTH + strlen(ptrn_friend) + 21 + id_str_len];
+
+    uint32_t i = 0;
+
+    while (getfriendname_terminated(m, i, name) != -1) {
+        if (!tox_get_client_id(m, i, fraddr_bin))
+            fraddr_to_str(fraddr_bin, fraddr_str);
+        else
+            sprintf(fraddr_str, "???");
+
         if (strlen(name) <= 0) {
-            sprintf(fstring, "[i] Friend: NULL\n\tid: %i", i);
+            sprintf(fstring, ptrn_friend, i, "No name?", fraddr_str);
         } else {
-            sprintf(fstring, "[i] Friend: %s\n\tid: %i", (uint8_t*)name, i);
+            sprintf(fstring, ptrn_friend, i, (uint8_t *)name, fraddr_str);
         }
+
+        i++;
         new_lines(fstring);
     }
+
+    if (i == 0)
+        new_lines("+ no friends! D:");
 }
 
-char *format_message(char *message, int friendnum)
+static int fmtmsg_tm_mday = -1;
+
+static void print_formatted_message(Tox *m, char *message, int friendnum, uint8_t outgoing)
 {
-    char name[MAX_NAME_LENGTH];
-    if (friendnum != -1) {
-            getname(friendnum, (uint8_t*)name);
-    } else {
-            getself_name((uint8_t*)name);
-    }
-    char *msg = malloc(100+strlen(message)+strlen(name)+1);
+    char name[TOX_MAX_NAME_LENGTH + 1];
+    getfriendname_terminated(m, friendnum, name);
+
+    char msg[100 + strlen(message) + strlen(name) + 1];
 
     time_t rawtime;
-    struct tm * timeinfo;
+    struct tm *timeinfo;
     time ( &rawtime );
     timeinfo = localtime ( &rawtime );
-    char* time = asctime(timeinfo);
-    size_t len = strlen(time);
-    time[len-1] = '\0';
-    sprintf(msg, "[%d] %s <%s> %s", friendnum, time, name, message); // timestamp
-    return msg;
+
+    /* assume that printing the date once a day is enough */
+    if (fmtmsg_tm_mday != timeinfo->tm_mday) {
+        fmtmsg_tm_mday = timeinfo->tm_mday;
+        /* strftime(msg, 100, "Today is %a %b %d %Y.", timeinfo); */
+        /* %x is the locale's preferred date format */
+        strftime(msg, 100, "Today is %x.", timeinfo);
+        new_lines(msg);
+    }
+
+    char time[64];
+    /* strftime(time, 64, "%I:%M:%S %p", timeinfo); */
+    /* %X is the locale's preferred time format */
+    strftime(time, 64, "%X", timeinfo);
+
+    if (outgoing) {
+        /* tgt: friend */
+        sprintf(msg, "[%d] %s =>{%s} %s", friendnum, time, name, message);
+    } else {
+        /* src: friend */
+        sprintf(msg, "[%d] %s <%s>: %s", friendnum, time, name, message);
+    }
+
+    new_lines(msg);
 }
 
-void line_eval(char lines[HISTORY][STRING_LENGTH], char *line)
+/* forward declarations */
+static int save_data(Tox *m);
+void print_groupchatpeers(Tox *m, int groupnumber);
+
+void line_eval(Tox *m, char *line)
 {
     if (line[0] == '/') {
         char inpt_command = line[1];
-        char prompt[STRING_LENGTH+2] = "> ";
+        char prompt[STRING_LENGTH + 2] = "> ";
         int prompt_offset = 3;
         strcat(prompt, line);
         new_lines(prompt);
+
         if (inpt_command == 'f') { // add friend command: /f ID
-            int i;
+            int i, delta = 0;
             char temp_id[128];
-            for (i = 0; i < 128; i++) 
-                temp_id[i] = line[i+prompt_offset];
-            int num = m_addfriend(hex_string_to_bin(temp_id), (uint8_t*)"Install Gentoo", sizeof("Install Gentoo"));
+
+            for (i = 0; i < 128; i++) {
+                temp_id[i - delta] = line[i + prompt_offset];
+
+                if ((temp_id[i - delta] == ' ') || (temp_id[i - delta] == '+'))
+                    delta++;
+            }
+
+            unsigned char *bin_string = hex_string_to_bin(temp_id);
+            int num = tox_add_friend(m, bin_string, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo"));
+            free(bin_string);
             char numstring[100];
+
             switch (num) {
-                case -1:
-                    sprintf(numstring, "[i] Incorrect key length");
+                case TOX_FAERR_TOOLONG:
+                    sprintf(numstring, "[i] Message is too long.");
+                    break;
+
+                case TOX_FAERR_NOMESSAGE:
+                    sprintf(numstring, "[i] Please add a message to your request.");
                     break;
-                case -2:
-                    sprintf(numstring, "[i] That appears to be your own key");
+
+                case TOX_FAERR_OWNKEY:
+                    sprintf(numstring, "[i] That appears to be your own ID.");
                     break;
-                case -3:
-                    sprintf(numstring, "[i] Friend request already sent");
+
+                case TOX_FAERR_ALREADYSENT:
+                    sprintf(numstring, "[i] Friend request already sent.");
                     break;
-                case -4:
-                    sprintf(numstring, "[i] Could not add friend");
+
+                case TOX_FAERR_UNKNOWN:
+                    sprintf(numstring, "[i] Undefined error when adding friend.");
                     break;
+
                 default:
-                    sprintf(numstring, "[i] Added friend %d", num);
+                    if (num >= 0) {
+                        sprintf(numstring, "[i] Added friend as %d.", num);
+                        save_data(m);
+                    } else
+                        sprintf(numstring, "[i] Unknown error %i.", num);
+
                     break;
             }
+
             new_lines(numstring);
-            do_refresh();
-        }
-        else if (inpt_command == 'd') {
-            doMessenger();
-        }
-        else if (inpt_command == 'm') { //message command: /m friendnumber messsage
-            size_t len = strlen(line);
-	    if(len < 3)
-	      return;
-
-            char numstring[len-3];
-            char message[len-3];
-            int i;
-            for (i = 0; i < len; i++) {
-                if (line[i+3] != ' ') {
-                    numstring[i] = line[i+3];
+        } else if (inpt_command == 'd') {
+            tox_do(m);
+        } else if (inpt_command == 'm') { //message command: /m friendnumber messsage
+            char *posi[1];
+            int num = strtoul(line + prompt_offset, posi, 0);
+
+            if (**posi != 0) {
+                if (tox_send_message(m, num, (uint8_t *) *posi + 1, strlen(*posi + 1)) < 1) {
+                    char sss[256];
+                    sprintf(sss, "[i] could not send message to friend num %u", num);
+                    new_lines(sss);
                 } else {
-                    int j;
-                    for (j = (i+1); j < (len+1); j++)
-                        message[j-i-1] = line[j+3];
-                    break;
+                    print_formatted_message(m, *posi + 1, num, 1);
                 }
-            }
-            int num = atoi(numstring);
-            if (m_sendmessage(num, (uint8_t*) message, strlen(message) + 1) != 1) {
-                new_lines("[i] could not send message");
-            } else {
-                new_lines(format_message(message, -1));
-            }
-        }
-        else if (inpt_command == 'n') {
-            uint8_t name[MAX_NAME_LENGTH];
-            int i = 0;
-            size_t len = strlen(line);
+            } else
+                new_lines("Error, bad input.");
+        } else if (inpt_command == 'n') {
+            uint8_t name[TOX_MAX_NAME_LENGTH];
+            size_t i, len = strlen(line);
+
             for (i = 3; i < len; i++) {
                 if (line[i] == 0 || line[i] == '\n') break;
-                name[i-3] = line[i];
+
+                name[i - 3] = line[i];
             }
-            name[i-3] = 0;
-            setname(name, i - 2);
+
+            name[i - 3] = 0;
+            tox_set_name(m, name, i - 2);
             char numstring[100];
-            sprintf(numstring, "[i] changed nick to %s", (char*)name);
+            sprintf(numstring, "[i] changed nick to %s", (char *)name);
             new_lines(numstring);
-        }
-        else if (inpt_command == 'l') {
-            print_friendlist();
-        }
-        else if (inpt_command == 's') {
-            uint8_t status[MAX_USERSTATUS_LENGTH];
-            int i = 0;
-            size_t len = strlen(line);
+        } else if (inpt_command == 'l') {
+            print_friendlist(m);
+        } else if (inpt_command == 's') {
+            uint8_t status[TOX_MAX_STATUSMESSAGE_LENGTH];
+            size_t i, len = strlen(line);
+
             for (i = 3; i < len; i++) {
                 if (line[i] == 0 || line[i] == '\n') break;
-                status[i-3] = line[i];
+
+                status[i - 3] = line[i];
             }
-            status[i-3] = 0;
-            m_set_userstatus(status, strlen((char*)status) + 1);
+
+            status[i - 3] = 0;
+            tox_set_status_message(m, status, strlen((char *)status));
             char numstring[100];
-            sprintf(numstring, "[i] changed status to %s", (char*)status);
+            sprintf(numstring, "[i] changed status to %s", (char *)status);
             new_lines(numstring);
-        }
-        else if (inpt_command == 'a') {
+        } else if (inpt_command == 'a') { // /a #: accept
             uint8_t numf = atoi(line + 3);
             char numchar[100];
-            int num = m_addfriend_norequest(pending_requests[numf]);
-            if (num != -1) {
-                sprintf(numchar, "[i] friend request %u accepted", numf);
-                new_lines(numchar);
-                sprintf(numchar, "[i] added friendnumber %d", num);
+
+            if (numf >= num_requests || pending_requests[numf].accepted) {
+                sprintf(numchar, "[i] you either didn't receive that request or you already accepted it");
                 new_lines(numchar);
             } else {
-                sprintf(numchar, "[i] failed to add friend");
-                new_lines(numchar);
+                int num = tox_add_friend_norequest(m, pending_requests[numf].id);
+
+                if (num != -1) {
+                    pending_requests[numf].accepted = 1;
+                    sprintf(numchar, "[i] friend request %u accepted as friend no. %d", numf, num);
+                    new_lines(numchar);
+                    save_data(m);
+                } else {
+                    sprintf(numchar, "[i] failed to add friend");
+                    new_lines(numchar);
+                }
             }
-            do_refresh();
-        }
-       else if (inpt_command == 'h') { //help
-           new_lines("[i] commands: /f ID (to add friend), /m friendnumber message  (to send message), /s status (to change status)");
-           new_lines("[i] /l list (list friends), /h for help, /i for info, /n nick (to change nickname), /q (to quit)");
-        }
-       else if (inpt_command == 'i') { //info
-           char idstring0[200];
-           char idstring1[PUB_KEY_BYTES][5];
-           char idstring2[PUB_KEY_BYTES][5];
-           int i;
-           for (i = 0; i < PUB_KEY_BYTES; i++)
-           {
-               if (self_public_key[i] < (PUB_KEY_BYTES/2))
-                   strcpy(idstring1[i],"0");
-               else 
-                   strcpy(idstring1[i], "");
-               sprintf(idstring2[i], "%hhX", self_public_key[i]);
-           }
-           //
-           strcpy(idstring0,"[i] ID: ");
-           int j;
-           for (j = 0; j < PUB_KEY_BYTES; j++) {
-               strcat(idstring0,idstring1[j]);
-               strcat(idstring0,idstring2[j]);
-           }    
-                  new_lines(idstring0);
-       }
-
-        else if (inpt_command == 'q') { //exit
+        } else if (inpt_command == 'r') { // /r #: remove friend
+            uint8_t numf = atoi(line + 3);
+
+            if (!tox_friend_exists(m, numf)) {
+                char err[64];
+                sprintf(err, "You don't have a friend %i.", numf);
+                new_lines(err);
+                return;
+            }
+
+            char msg[128 + TOX_MAX_NAME_LENGTH];
+            char fname[TOX_MAX_NAME_LENGTH ];
+            getfriendname_terminated(m, numf, fname);
+            sprintf(msg, "Are you sure you want to delete friend %i: %s? (y/n)", numf, fname);
+            input_line[0] = 0;
+            new_lines(msg);
+
+            int c;
+
+            do {
+                c = getchar();
+            } while ((c != 'y') && (c != 'n') && (c != EOF));
+
+            if (c == 'y') {
+                int res = tox_del_friend(m, numf);
+
+                if (res == 0)
+                    sprintf(msg, "[i] [%i: %s] is no longer your friend", numf, fname);
+                else
+                    sprintf(msg, "[i] failed to remove friend");
+
+                new_lines(msg);
+            }
+        } else if (inpt_command == 'h') { //help
+            if (line[2] == ' ') {
+                if (line[3] == 'f') {
+                    new_lines_mark(help_friend1, 1);
+                    new_lines_mark(help_friend2, 1);
+                    return;
+                } else if (line[3] == 'g') {
+                    new_lines_mark(help_group, 1);
+                    return;
+                }
+            }
+
+            new_lines_mark(help_main, 1);
+        } else if (inpt_command == 'x') { //info
+            char idstring[200];
+            get_id(m, idstring);
+            new_lines(idstring);
+        } else if (inpt_command == 'g') { //create new group chat
+            char msg[256];
+            sprintf(msg, "[g] Created new group chat with number: %u", tox_add_groupchat(m));
+            new_lines(msg);
+        } else if (inpt_command == 'i') { //invite friendnum to groupnum
+            char *posi[1];
+            int friendnumber = strtoul(line + prompt_offset, posi, 0);
+            int groupnumber = strtoul(*posi + 1, NULL, 0);
+            char msg[256];
+            sprintf(msg, "[g] Invited friend number %u to group number %u, returned: %u (0 means success)", friendnumber,
+                    groupnumber, tox_invite_friend(m, friendnumber, groupnumber));
+            new_lines(msg);
+        } else if (inpt_command == 'z') { //send message to groupnum
+            char *posi[1];
+            int groupnumber = strtoul(line + prompt_offset, posi, 0);
+
+            if (**posi != 0) {
+                int res = tox_group_message_send(m, groupnumber, (uint8_t *)*posi + 1, strlen(*posi + 1));
+
+                if (res == 0) {
+                    char msg[32 + STRING_LENGTH];
+                    sprintf(msg, "[g] #%u: YOU: %s", groupnumber, *posi + 1);
+                    new_lines(msg);
+                } else {
+                    char msg[128];
+                    sprintf(msg, "[i] could not send message to group no. %u: %i", groupnumber, res);
+                    new_lines(msg);
+                }
+            }
+        } else if (inpt_command == 't') {
+            char *posi[1];
+            int friendnum = strtoul(line + prompt_offset, posi, 0);
+
+            if (**posi != 0) {
+                char msg[512];
+                sprintf(msg, "[t] Sending file %s to friendnum %u filenumber is %i (-1 means failure)", *posi + 1, friendnum,
+                        add_filesender(m, friendnum, *posi + 1));
+                new_lines(msg);
+            }
+        } else if (inpt_command == 'q') { //exit
+            save_data(m);
             endwin();
+            tox_kill(m);
             exit(EXIT_SUCCESS);
-        } else { 
+        } else if (inpt_command == 'c') { //set conversation partner
+            if (line[2] == 'r') {
+                if (conversation_default != 0) {
+                    conversation_default = 0;
+                    new_lines("[i] default conversation reset");
+                } else
+                    new_lines("[i] default conversation wasn't set, nothing to do");
+            } else if (line[3] != ' ') {
+                new_lines("[i] invalid command");
+            } else {
+                int num = atoi(line + 4);
+
+                /* zero is also returned for not-a-number */
+                if (!num && strcmp(line + 4, "0"))
+                    num = -1;
+
+                if (num < 0)
+                    new_lines("[i] invalid command parameter");
+                else if (line[2] == 'f') {
+                    conversation_default = num + 1;
+                    char buffer[128];
+                    sprintf(buffer, "[i] default conversation is now to friend %i", num);
+                    new_lines(buffer);
+                } else if (line[2] == 'g') {
+                    char buffer[128];
+                    conversation_default = - (num + 1);
+                    sprintf(buffer, "[i] default conversation is now to group %i", num);
+                    new_lines(buffer);
+                } else
+                    new_lines("[i] invalid command");
+            }
+        } else if (inpt_command == 'p') { //list peers
+            char *posi = NULL;
+            int group_number = strtoul(line + prompt_offset, &posi, 0);
+
+            if (posi != NULL) {
+                char msg[64];
+                int peer_cnt = tox_group_number_peers(m, group_number);
+
+                if (peer_cnt < 0) {
+                    new_lines("[g] Invalid group number.");
+                } else if (peer_cnt == 0) {
+                    sprintf(msg, "[g] #%i: No peers in group.", group_number);
+                    new_lines(msg);
+                } else {
+                    sprintf(msg, "[g] #%i: Group has %i peers. Names:", group_number, peer_cnt);
+                    new_lines(msg);
+                    print_groupchatpeers(m, group_number);
+                }
+            }
+        } else {
             new_lines("[i] invalid command");
         }
     } else {
-        new_lines("[i] invalid command");
-        //new_lines(line);
+        if (conversation_default != 0) {
+            if (conversation_default > 0) {
+                int friendnumber = conversation_default - 1;
+                uint32_t res = tox_send_message(m, friendnumber, (uint8_t *)line, strlen(line));
+
+                if (res == 0) {
+                    char sss[128];
+                    sprintf(sss, "[i] could not send message to friend no. %u", friendnumber);
+                    new_lines(sss);
+                } else
+                    print_formatted_message(m, line, friendnumber, 1);
+            } else {
+                int groupnumber = - conversation_default - 1;
+                int res = tox_group_message_send(m, groupnumber, (uint8_t *)line, strlen(line));
+
+                if (res == 0) {
+                    char msg[32 + STRING_LENGTH];
+                    sprintf(msg, "[g] #%u: YOU: %s", groupnumber, line);
+                    new_lines(msg);
+                } else {
+                    char msg[128];
+                    sprintf(msg, "[i] could not send message to group no. %u: %i", groupnumber, res);
+                    new_lines(msg);
+                }
+            }
+        } else
+            new_lines("[i] invalid input: neither command nor in conversation");
     }
 }
 
-void wrap(char output[STRING_LENGTH], char input[STRING_LENGTH], int line_width)
+/* basic wrap, ignores embedded '\t', '\n' or '|'
+ * inserts continuation markers if there's enough space left,
+ * otherwise turns spaces into newlines if possible */
+void wrap(char output[STRING_LENGTH_WRAPPED], char input[STRING_LENGTH], int line_width)
 {
-    strcpy(output,input);
-    size_t len = strlen(output);
-    int i = 0;
-    for (i = line_width; i < len; i = i + line_width) {
-        while (output[i] != ' ' && i != 0) {
-            i--;
+    size_t i, len = strlen(input);
+
+    if ((line_width < 4) || (len < (size_t)line_width)) {
+        /* if line_width ridiculously tiny, it's not worth the effort */
+        strcpy(output, input);
+        return;
+    }
+
+    /* how much can we shift? */
+    size_t delta_is = 0, delta_remain = STRING_LENGTH_WRAPPED - len - 1;
+
+    /* if the line is very very short, don't insert continuation markers,
+     * as they would use up too much of the line */
+    if ((size_t)line_width < 2 * wrap_cont_len)
+        delta_remain = 0;
+
+    for (i = line_width; i < len; i += line_width) {
+        /* look backward for a space to expand/turn into a new line */
+        size_t k = i;
+        size_t m = i - line_width;
+
+        while (input[k] != ' ' && k > m) {
+            k--;
+        }
+
+        if (k > m) {
+            if (delta_remain > wrap_cont_len) {
+                /* replace space with continuation, then
+                 * set the pos. after the space as new line start
+                 * (i.e. space is being "eaten") */
+                memcpy(output + m + delta_is, input + m, k - m);
+                strcpy(output + k + delta_is, wrap_cont_str);
+
+                delta_remain -= wrap_cont_len - 1;
+                delta_is += wrap_cont_len - 1;
+                i = k + 1;
+            } else {
+                /* no more space to push forward: replace the space,
+                 * use its pos. + 1 as starting point for the next line */
+                memcpy(output + m + delta_is, input + m, k - m);
+                output[k + delta_is] = '\n';
+                i = k + 1;
+            }
+        } else {
+            /* string ends right here:
+             * don't add a continuation marker with nothing following */
+            if (i == len - 1)
+                break;
+
+            /* nothing found backwards */
+            if (delta_remain > wrap_cont_len) {
+                /* break at the end of the line,
+                 * i.e. in the middle of the word at the border */
+                memcpy(output + m + delta_is, input + m, line_width);
+                strcpy(output + i + delta_is, wrap_cont_str);
+
+                delta_remain -= wrap_cont_len;
+                delta_is += wrap_cont_len;
+            } else {
+                /* no more space to push, no space to convert:
+                 * just copy the whole line and move on;
+                 * means the line count calc'ed will be off */
+                memcpy(output + m + delta_is, input + m, line_width);
+            }
         }
-        if (i > 0) {
-            output[i] = '\n';
+    }
+
+    i -= line_width;
+    memcpy(output + i + delta_is, input + i, len - i);
+
+    output[len + delta_is] = 0;
+}
+
+/*
+ * extended wrap, honors '\n', accepts '|' as "break here when necessary"
+ * marks wrapped lines with "+ " in front, which does expand output
+ * does NOT honor '\t': would require a lot more work (and tab width isn't always 8)
+ */
+void wrap_bars(char output[STRING_LENGTH_WRAPPED], char input[STRING_LENGTH], size_t line_width)
+{
+    size_t len = strlen(input);
+    size_t ipos, opos = 0;
+    size_t bar_avail = 0, space_avail = 0, nl_got = 0;   /* in opos */
+
+    for (ipos = 0; ipos < len; ipos++) {
+        if (opos - nl_got < line_width) {
+            /* not yet at the limit */
+            char c = input[ipos];
+
+            if (c == ' ')
+                space_avail = opos;
+
+            output[opos++] = input[ipos];
+
+            if (opos >= STRING_LENGTH_WRAPPED) {
+                opos = STRING_LENGTH_WRAPPED - 1;
+                break;
+            }
+
+            if (c == '|') {
+                output[opos - 1] = ' ';
+                bar_avail = opos;
+
+                if (opos + 2 >= STRING_LENGTH_WRAPPED) {
+                    opos = STRING_LENGTH_WRAPPED - 1;
+                    break;
+                }
+
+                output[opos++] = '|';
+                output[opos++] = ' ';
+            }
+
+            if (c == '\n')
+                nl_got = opos;
+
+            continue;
+        } else {
+            /* at the limit */
+            if (bar_avail > nl_got) {
+                /* overwrite */
+                memcpy(output + bar_avail - 1, wrap_cont_str, wrap_cont_len);
+                nl_got = bar_avail;
+
+                ipos--;
+                continue;
+            }
+
+            if (space_avail > nl_got) {
+                if (opos + wrap_cont_len - 1 >= STRING_LENGTH_WRAPPED) {
+                    opos = STRING_LENGTH_WRAPPED - 1;
+                    break;
+                }
+
+                /* move forward by 2 characters */
+                memmove(output + space_avail + 3, output + space_avail + 1, opos - (space_avail + 1));
+                memcpy(output + space_avail, wrap_cont_str, wrap_cont_len);
+                nl_got = space_avail + 1;
+
+                opos += 2;
+                ipos--;
+                continue;
+            }
+
+            char c = input[ipos];
+
+            if ((c == '|') || (c == ' ') || (c == '\n')) {
+                if (opos + wrap_cont_len >= STRING_LENGTH_WRAPPED) {
+                    opos = STRING_LENGTH_WRAPPED - 1;
+                    break;
+                }
+
+                memcpy(output + opos, wrap_cont_str, wrap_cont_len);
+
+                nl_got = opos;
+                opos += wrap_cont_len;
+            }
+
+            output[opos++] = input[ipos];
+
+            if (opos >= STRING_LENGTH_WRAPPED) {
+                opos = STRING_LENGTH_WRAPPED - 1;
+                break;
+            }
+
+            continue;
         }
     }
+
+    if (opos >= STRING_LENGTH_WRAPPED)
+        opos = STRING_LENGTH_WRAPPED - 1;
+
+    output[opos] = 0;
 }
 
 int count_lines(char *string)
 {
-    size_t len = strlen(string);
+    size_t i, len = strlen(string);
     int count = 1;
-    int i;
+
     for (i = 0; i < len; i++) {
         if (string[i] == '\n')
             count++;
     }
+
     return count;
 }
 
 char *appender(char *str, const char c)
 {
     size_t len = strlen(str);
+
     if (len < STRING_LENGTH) {
-        str[len+1] = str[len];
+        str[len + 1] = str[len];
         str[len] = c;
     }
+
     return str;
 }
 
 void do_refresh()
 {
-    int count=0;
-    char wrap_output[STRING_LENGTH];
-    int L;
+    int count = 0;
+    char wrap_output[STRING_LENGTH_WRAPPED];
     int i;
+
     for (i = 0; i < HISTORY; i++) {
-        wrap(wrap_output, lines[i], x);
-        L = count_lines(wrap_output);
+        if (flag[i])
+            wrap_bars(wrap_output, lines[i], x);
+        else
+            wrap(wrap_output, lines[i], x);
+
+        int L = count_lines(wrap_output);
         count = count + L;
+
         if (count < y) {
-            move(y-1-count, 0);
-            printw(wrap_output);
+            move(y - 1 - count, 0);
+            printw("%s", wrap_output);
             clrtoeol();
         }
     }
-    move(y-1, 0);
+
+    move(y - 1, 0);
     clrtoeol();
     printw(">> ");
-    printw(line);
+    printw("%s", input_line);
     clrtoeol();
     refresh();
 }
 
-void print_request(uint8_t *public_key, uint8_t *data, uint16_t length)
+void print_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
 {
     new_lines("[i] received friend request with message:");
     new_lines((char *)data);
     char numchar[100];
     sprintf(numchar, "[i] accept request with /a %u", num_requests);
     new_lines(numchar);
-    memcpy(pending_requests[num_requests], public_key, CLIENT_ID_SIZE);
+    memcpy(pending_requests[num_requests].id, public_key, TOX_CLIENT_ID_SIZE);
+    pending_requests[num_requests].accepted = 0;
     ++num_requests;
     do_refresh();
 }
 
-void print_message(int friendnumber, uint8_t * string, uint16_t length)
+void print_message(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
-    char name[MAX_NAME_LENGTH];
-    getname(friendnumber, (uint8_t*)name);
-    char msg[100+length+strlen(name)+1];
-    time_t rawtime;
-    struct tm * timeinfo;
-    time ( &rawtime );
-    timeinfo = localtime ( &rawtime );
-    char* temp = asctime(timeinfo);
-    size_t len = strlen(temp);
-    temp[len-1] = '\0';
-    sprintf(msg, "[%d] %s <%s> %s", friendnumber, temp, name, string); // timestamp
-    new_lines(format_message((char*)string, friendnumber));
+    /* ensure null termination */
+    uint8_t null_string[length + 1];
+    memcpy(null_string, string, length);
+    null_string[length] = 0;
+    print_formatted_message(m, (char *)null_string, friendnumber, 0);
 }
 
-void print_nickchange(int friendnumber, uint8_t *string, uint16_t length) 
+void print_nickchange(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
-    char name[MAX_NAME_LENGTH];
-    getname(friendnumber, (uint8_t*)name);
-    char msg[100+length];
-    sprintf(msg, "[i] [%d] %s is now known as %s.", friendnumber, name, string);
-    new_lines(msg);
+    char name[TOX_MAX_NAME_LENGTH + 1];
+
+    if (getfriendname_terminated(m, friendnumber, name) != -1) {
+        char msg[100 + length];
+
+        if (name[0] != 0)
+            sprintf(msg, "[i] [%d] %s is now known as %s.", friendnumber, name, string);
+        else
+            sprintf(msg, "[i] [%d] Friend's name is %s.", friendnumber, string);
+
+        new_lines(msg);
+    }
 }
 
-void print_statuschange(int friendnumber, uint8_t *string, uint16_t length) 
+void print_statuschange(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
-    char name[MAX_NAME_LENGTH];
-    getname(friendnumber, (uint8_t*)name);
-    char msg[100+length+strlen(name)+1];
-    sprintf(msg, "[i] [%d] %s's status changed to %s.", friendnumber, name, string);
-    new_lines(msg);
+    char name[TOX_MAX_NAME_LENGTH + 1];
+
+    if (getfriendname_terminated(m, friendnumber, name) != -1) {
+        char msg[100 + length + strlen(name) + 1];
+
+        if (name[0] != 0)
+            sprintf(msg, "[i] [%d] %s's status changed to %s.", friendnumber, name, string);
+        else
+            sprintf(msg, "[i] [%d] Their status changed to %s.", friendnumber, string);
+
+        new_lines(msg);
+    }
 }
 
-void load_key() 
+static char *data_file_name = NULL;
+
+static int load_data(Tox *m)
 {
-    FILE *data_file = NULL;
-    data_file = fopen("data","r");
+    FILE *data_file = fopen(data_file_name, "r");
+
     if (data_file) {
-        //load keys
         fseek(data_file, 0, SEEK_END);
-        int size = ftell(data_file);
-        fseek(data_file, 0, SEEK_SET);
+        size_t size = ftell(data_file);
+        rewind(data_file);
+
         uint8_t data[size];
-        if (fread(data, sizeof(uint8_t), size, data_file) != size){
-            printf("[i] could not read data file\n[i] exiting\n");
-            exit(1);
+
+        if (fread(data, sizeof(uint8_t), size, data_file) != size) {
+            fputs("[!] could not read data file!\n", stderr);
+            fclose(data_file);
+            return 0;
         }
-        Messenger_load(data, size);
-    } else { 
-        //else save new keys
-        int size = Messenger_size();
-        uint8_t data[size];
-        Messenger_save(data);
-        data_file = fopen("data","w");
-        if (fwrite(data, sizeof(uint8_t), size, data_file) != size){
-            printf("[i] could not write data file\n[i] exiting\n");
-            exit(1);
+
+        tox_load(m, data, size);
+
+        if (fclose(data_file) < 0) {
+            perror("[!] fclose failed");
+            /* we got it open and the expected data read... let it be ok */
+            /* return 0; */
         }
+
+        return 1;
     }
-   fclose(data_file);
+
+    return 0;
 }
 
-int main(int argc, char *argv[])
+static int save_data(Tox *m)
 {
-    if (argc < 4) {
-        printf("[!] Usage: %s [IP] [port] [public_key] <nokey>\n", argv[0]);
-        exit(0);
+    FILE *data_file = fopen(data_file_name, "w");
+
+    if (!data_file) {
+        perror("[!] load_key");
+        return 0;
     }
-    int c;
-    int on = 0;
-    initMessenger();
-    //if keyfiles exist
-    if(argc > 4){
-        if(strncmp(argv[4], "nokey", 6) < 0){
-        //load_key();
+
+    int res = 1;
+    size_t size = tox_size(m);
+    uint8_t data[size];
+    tox_save(m, data);
+
+    if (fwrite(data, sizeof(uint8_t), size, data_file) != size) {
+        fputs("[!] could not write data file (1)!", stderr);
+        res = 0;
+    }
+
+    if (fclose(data_file) < 0) {
+        perror("[!] could not write data file (2)");
+        res = 0;
+    }
+
+    return res;
+}
+
+static int load_data_or_init(Tox *m, char *path)
+{
+    data_file_name = path;
+
+    if (load_data(m))
+        return 1;
+
+    if (save_data(m))
+        return 1;
+
+    return 0;
+}
+
+void print_help(char *prog_name)
+{
+    printf("nTox %.1f - Command-line tox-core client\n", 0.1);
+    printf("Usage: %s [--ipv4|--ipv6] IP PORT KEY [-f keyfile]\n", prog_name);
+
+    puts("Options: (order IS relevant)");
+    puts("  --ipv4 / --ipv6 [Optional] Support IPv4 only or IPv4 & IPv6.");
+    puts("  IP PORT KEY     [REQUIRED] A node to connect to (IP/Port) and its key.");
+    puts("  -f keyfile      [Optional] Specify a keyfile to read from and write to.");
+}
+
+void print_invite(Tox *m, int friendnumber, const uint8_t *group_public_key, void *userdata)
+{
+    char msg[256];
+    sprintf(msg, "[i] received group chat invite from: %u, auto accepting and joining. group number: %u", friendnumber,
+            tox_join_groupchat(m, friendnumber, group_public_key));
+    new_lines(msg);
+}
+
+void print_groupchatpeers(Tox *m, int groupnumber)
+{
+    int num = tox_group_number_peers(m, groupnumber);
+
+    if (num < 0)
+        return;
+
+    if (!num) {
+        new_lines("[g]+ no peers left in group.");
+        return;
+    }
+
+    uint8_t names[num][TOX_MAX_NAME_LENGTH];
+    uint16_t lengths[num];
+    tox_group_get_names(m, groupnumber, names, lengths, num);
+    int i;
+    char numstr[16];
+    char header[] = "[g]+ ";
+    size_t header_len = strlen(header);
+    char msg[STRING_LENGTH];
+    strcpy(msg, header);
+    size_t len_total = header_len;
+
+    for (i = 0; i < num; ++i) {
+        size_t len_name = lengths[i];
+        size_t len_num = sprintf(numstr, "%i: ", i);
+
+        if (len_num + len_name + len_total + 3 >= STRING_LENGTH) {
+            new_lines_mark(msg, 1);
+
+            strcpy(msg, header);
+            len_total = header_len;
+        }
+
+        strcpy(msg + len_total, numstr);
+        len_total += len_num;
+        memcpy(msg + len_total, (char *)names[i], len_name);
+        len_total += len_name;
+
+        if (i < num - 1) {
+            strcpy(msg + len_total, "|");
+            len_total++;
+        }
+    }
+
+    new_lines_mark(msg, 1);
+}
+
+void print_groupmessage(Tox *m, int groupnumber, int peernumber, const uint8_t *message, uint16_t length,
+                        void *userdata)
+{
+    char msg[256 + length];
+    uint8_t name[TOX_MAX_NAME_LENGTH] = {0};
+    int len = tox_group_peername(m, groupnumber, peernumber, name);
+
+    //print_groupchatpeers(m, groupnumber);
+    if (len <= 0)
+        name[0] = 0;
+
+    if (name[0] != 0)
+        sprintf(msg, "[g] %u: %u <%s>: %s", groupnumber, peernumber, name, message);
+    else
+        sprintf(msg, "[g] #%u: %u Unknown: %s", groupnumber, peernumber, message);
+
+    new_lines(msg);
+}
+void print_groupnamelistchange(Tox *m, int groupnumber, int peernumber, uint8_t change, void *userdata)
+{
+    char msg[256];
+
+    if (change == TOX_CHAT_CHANGE_PEER_ADD) {
+        sprintf(msg, "[g] #%i: New peer %i.", groupnumber, peernumber);
+        new_lines(msg);
+    } else if (change == TOX_CHAT_CHANGE_PEER_DEL) {
+        /* if peer was the last in list, it simply dropped,
+         * otherwise it was overwritten by the last peer
+         *
+         * adjust output
+         */
+        int peers_total = tox_group_number_peers(m, groupnumber);
+
+        if (peers_total == peernumber) {
+            sprintf(msg, "[g] #%i: Peer %i left.", groupnumber, peernumber);
+            new_lines(msg);
+        } else {
+            uint8_t peername[TOX_MAX_NAME_LENGTH] = {0};
+            int len = tox_group_peername(m, groupnumber, peernumber, peername);
+
+            if (len <= 0)
+                peername[0] = 0;
+
+            sprintf(msg, "[g] #%i: Peer %i left. Former peer [%i: <%s>] is now peer %i.", groupnumber, peernumber,
+                    peers_total, peername, peernumber);
+            new_lines(msg);
         }
+    } else if (change == TOX_CHAT_CHANGE_PEER_NAME) {
+        uint8_t peername[TOX_MAX_NAME_LENGTH] = {0};
+        int len = tox_group_peername(m, groupnumber, peernumber, peername);
+
+        if (len <= 0)
+            peername[0] = 0;
+
+        sprintf(msg, "[g] #%i: Peer %i's name changed: %s", groupnumber, peernumber, peername);
+        new_lines(msg);
     } else {
-        load_key();
+        sprintf(msg, "[g] #%i: Name list changed (peer %i, change %i?):", groupnumber, peernumber, change);
+        new_lines(msg);
+        print_groupchatpeers(m, groupnumber);
     }
-    m_callback_friendrequest(print_request);
-    m_callback_friendmessage(print_message);
-    m_callback_namechange(print_nickchange);
-    m_callback_userstatus(print_statuschange);
-    char idstring0[200];
-    char idstring1[PUB_KEY_BYTES][5];
-    char idstring2[PUB_KEY_BYTES][5];
-    int i;
-    for(i = 0; i < PUB_KEY_BYTES; i++)
-    {
-        if (self_public_key[i] < (PUB_KEY_BYTES / 2))
-            strcpy(idstring1[i],"0");
-        else 
-            strcpy(idstring1[i], "");
-        sprintf(idstring2[i], "%hhX",self_public_key[i]);
+}
+void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, const uint8_t *filename,
+                         uint16_t filename_length, void *userdata)
+{
+    char msg[512];
+    sprintf(msg, "[t] %u is sending us: %s of size %llu", friendnumber, filename, (long long unsigned int)filesize);
+    new_lines(msg);
+
+    if (tox_file_send_control(m, friendnumber, 1, filenumber, 0, 0, 0) == 0) {
+        sprintf(msg, "Accepted file transfer. (saving file as: %u.%u.bin)", friendnumber, filenumber);
+        new_lines(msg);
+    } else
+        new_lines("Could not accept file transfer.");
+}
+
+void file_print_control(Tox *m, int friendnumber, uint8_t send_recieve, uint8_t filenumber, uint8_t control_type,
+                        const uint8_t *data, uint16_t length, void *userdata)
+{
+    char msg[512] = {0};
+
+    if (control_type == 0)
+        sprintf(msg, "[t] %u accepted file transfer: %u", friendnumber, filenumber);
+    else if (control_type == 3)
+        sprintf(msg, "[t] %u file transfer: %u completed", friendnumber, filenumber);
+    else
+        sprintf(msg, "[t] control %u received", control_type);
+
+    new_lines(msg);
+}
+
+void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length, void *userdata)
+{
+    char filename[256];
+    sprintf(filename, "%u.%u.bin", friendnumber, filenumber);
+    FILE *pFile = fopen(filename, "a");
+
+    if (tox_file_data_remaining(m, friendnumber, filenumber, 1) == 0) {
+        //file_control(m, friendnumber, 1, filenumber, 3, 0, 0);
+        char msg[512];
+        sprintf(msg, "[t] %u file transfer: %u completed", friendnumber, filenumber);
+        new_lines(msg);
+    }
+
+    if (fwrite(data, length, 1, pFile) != 1)
+        new_lines("Error writing to file");
+
+    fclose(pFile);
+}
+
+char timeout_getch(Tox *m)
+{
+    char c;
+    int slpval = tox_do_interval(m);
+
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(0, &fds);
+    struct timeval tv;
+    tv.tv_sec = 0;
+    tv.tv_usec = slpval * 1000;
+
+    c = ERR;
+    int n = select(1, &fds, NULL, NULL, &tv);
+
+    if (n < 0) {
+        new_lines("select error: maybe interupted");
+    } else if (n == 0) {
+    } else {
+        c = getch();
+    }
+
+    return c;
+}
+
+int main(int argc, char *argv[])
+{
+    /* minimalistic locale support (i.e. when printing dates) */
+    setlocale(LC_ALL, "");
+
+    if (argc < 4) {
+        if ((argc == 2) && !strcmp(argv[1], "-h")) {
+            print_help(argv[0]);
+            exit(0);
+        }
+
+        printf("Usage: %s [--ipv4|--ipv6] IP PORT KEY [-f keyfile] (or %s -h for help)\n", argv[0], argv[0]);
+        exit(0);
     }
-    strcpy(idstring0,"[i] your ID: ");
-    int j;
-    for (j = 0; j < PUB_KEY_BYTES; j++) {
-        strcat(idstring0,idstring1[j]);
-        strcat(idstring0,idstring2[j]);
+
+    /* let user override default by cmdline */
+    uint8_t ipv6enabled = TOX_ENABLE_IPV6_DEFAULT; /* x */
+    int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled);
+
+    if (argvoffset < 0)
+        exit(1);
+
+    int on = 0;
+    char *filename = "data";
+    char idstring[200] = {0};
+    Tox *m;
+
+    /* [-f keyfile] MUST be last two arguments, no point in walking over the list
+     * especially not a good idea to accept it anywhere in the middle */
+    if (argc > argvoffset + 3)
+        if (!strcmp(argv[argc - 2], "-f"))
+            filename = argv[argc - 1];
+
+    m = tox_new(0);
+
+    if ( !m ) {
+        fputs("Failed to allocate Messenger datastructure", stderr);
+        exit(0);
     }
+
+    load_data_or_init(m, filename);
+
+    tox_callback_friend_request(m, print_request, NULL);
+    tox_callback_friend_message(m, print_message, NULL);
+    tox_callback_name_change(m, print_nickchange, NULL);
+    tox_callback_status_message(m, print_statuschange, NULL);
+    tox_callback_group_invite(m, print_invite, NULL);
+    tox_callback_group_message(m, print_groupmessage, NULL);
+    tox_callback_file_data(m, write_file, NULL);
+    tox_callback_file_control(m, file_print_control, NULL);
+    tox_callback_file_send_request(m, file_request_accept, NULL);
+    tox_callback_group_namelist_change(m, print_groupnamelistchange, NULL);
+
     initscr();
     noecho();
     raw();
     getmaxyx(stdscr, y, x);
-    new_lines(idstring0);
-    new_lines(help);
-    strcpy(line, "");
-    IP_Port bootstrap_ip_port;
-    bootstrap_ip_port.port = htons(atoi(argv[2]));
-    int resolved_address = resolve_addr(argv[1]);
-    if (resolved_address != 0)
-        bootstrap_ip_port.ip.i = resolved_address;
-    else 
+
+    new_lines("/h for list of commands");
+    get_id(m, idstring);
+    new_lines(idstring);
+    strcpy(input_line, "");
+
+    uint16_t port = atoi(argv[argvoffset + 2]);
+    unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]);
+    int res = tox_bootstrap_from_address(m, argv[argvoffset + 1], port, binary_string);
+
+    if (!res) {
+        printf("Failed to convert \"%s\" into an IP address. Exiting...\n", argv[argvoffset + 1]);
+        endwin();
         exit(1);
-    
-    DHT_bootstrap(bootstrap_ip_port, hex_string_to_bin(argv[3]));
+    }
+
     nodelay(stdscr, TRUE);
-    while(true) {
-        if (on == 0 && DHT_isconnected()) {
-            new_lines("[i] connected to DHT\n[i] define username with /n");
-            on = 1;
+
+    new_lines("[i] change username with /n");
+    uint8_t name[TOX_MAX_NAME_LENGTH + 1];
+    uint16_t namelen = tox_get_self_name(m, name);
+    name[namelen] = 0;
+
+    if (namelen > 0) {
+        char whoami[128 + TOX_MAX_NAME_LENGTH];
+        snprintf(whoami, sizeof(whoami), "[i] your current username is: %s", name);
+        new_lines(whoami);
+    }
+
+    time_t timestamp0 = time(NULL);
+
+    while (1) {
+        if (on == 0) {
+            if (tox_isconnected(m)) {
+                new_lines("[i] connected to DHT");
+                on = 1;
+            } else {
+                time_t timestamp1 = time(NULL);
+
+                if (timestamp0 + 10 < timestamp1) {
+                    timestamp0 = timestamp1;
+                    tox_bootstrap_from_address(m, argv[argvoffset + 1], port, binary_string);
+                }
+            }
         }
 
-        doMessenger();
-        c_sleep(1);
+
+
+        send_filesenders(m);
+        tox_do(m);
         do_refresh();
 
-        c = getch();
+        int c = timeout_getch(m);
+
         if (c == ERR || c == 27)
             continue;
 
         getmaxyx(stdscr, y, x);
-        if (c == '\n') {
-            line_eval(lines, line);
-            strcpy(line, "");
-        } else if (c == 127) {
-            line[strlen(line)-1] = '\0';
+
+        if ((c == 0x0d) || (c == 0x0a)) {
+            line_eval(m, input_line);
+            strcpy(input_line, "");
+        } else if (c == 8 || c == 127) {
+            input_line[strlen(input_line) - 1] = '\0';
         } else if (isalnum(c) || ispunct(c) || c == ' ') {
-            strcpy(line, appender(line, (char) c));
+            strcpy(input_line, appender(input_line, (char) c));
         }
     }
+
+    free(binary_string);
+    tox_kill(m);
     endwin();
     return 0;
 }