/*

* MiniTox - A minimal client for Tox

*/

#ifndef _POSIX_C_SOURCE

#define _POSIX_C_SOURCE 200809L

#endif

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <stdarg.h>

#include <termios.h>

#include <unistd.h>

#include <fcntl.h>

#include <tox/tox.h>

/*******************************************************************************

*

* Consts & Macros

*

******************************************************************************/

// where to save the tox data.

// if don't want to save, set it to NULL.

const char *savedata_filename = "./savedata.tox";

const char *savedata_tmp_filename = "./savedata.tox.tmp";

struct DHT_node {

};

struct DHT_node bootstrap_nodes[] = {

// Setup tox bootrap nodes

{"node.tox.biribiri.org", 33445, "F404ABAA1C99A9D37D61AB54898F56793E1DEF8BD46B1038B9D822E8460FAB67"},

{"128.199.199.197", 33445, "B05C8869DBB4EDDD308F43C1A974A20A725A36EACCA123862FDE9945BF9D3E09"},

{"2400:6180:0:d0::17a:a001", 33445, "B05C8869DBB4EDDD308F43C1A974A20A725A36EACCA123862FDE9945BF9D3E09"},

};

#define LINE_MAX_SIZE 512 // If input line's length surpassed this value, it will be truncated.

#define PORT_RANGE_START 33445 // tox listen port range

#define PORT_RANGE_END 34445

#define AREPL_INTERVAL 30 // Async REPL iterate interval. unit: millisecond.

#define DEFAULT_CHAT_HIST_COUNT 20 // how many items of chat history to show by default;

#define SAVEDATA_AFTER_COMMAND true // whether save data after executing any command

/// Macros for terminal display

#define CODE_ERASE_LINE "\r\033[2K"

#define RESET_COLOR "\x01b[0m"

#define SELF_TALK_COLOR "\x01b[35m" // magenta

#define GUEST_TALK_COLOR "\x01b[90m" // bright black

#define CMD_PROMPT_COLOR "\x01b[34m" // blue

#define CMD_PROMPT CMD_PROMPT_COLOR "> " RESET_COLOR // green

#define FRIEND_TALK_PROMPT CMD_PROMPT_COLOR "%-.12s << " RESET_COLOR

#define GROUP_TALK_PROMPT CMD_PROMPT_COLOR "%-.12s <<< " RESET_COLOR

#define GUEST_MSG_PREFIX GUEST_TALK_COLOR "%s .12s | " RESET_COLOR

#define SELF_MSG_PREFIX SELF_TALK_COLOR "%s .12s | " RESET_COLOR

#define CMD_MSG_PREFIX CMD_PROMPT

#define PRINT(_fmt, ...) \

fputs(CODE_ERASE_LINE,stdout);\

printf(_fmt "\n", ##__VA_ARGS__);

#define COLOR_PRINT(_color, _fmt,...) PRINT(_color _fmt RESET_COLOR, ##__VA_ARGS__)

#define INFO(_fmt,...) COLOR_PRINT("\x01b[36m", _fmt, ##__VA_ARGS__) // cyran

#define WARN(_fmt,...) COLOR_PRINT("\x01b[33m", _fmt, ##__VA_ARGS__) // yellow

#define ERROR(_fmt,...) COLOR_PRINT("\x01b[31m", _fmt, ##__VA_ARGS__) // red

/*******************************************************************************

*

* Headers

*

******************************************************************************/

Tox *tox;

typedef void CommandHandler(int narg, char **args);

struct Command {

};

struct GroupUserData {

};

struct FriendUserData {

uint8_t pubkey[TOX_PUBLIC_KEY_SIZE];

};

union RequestUserData {

struct GroupUserData group;

struct FriendUserData friend;

};

struct Request {

};

struct ChatHist {

};

struct GroupPeer {

uint8_t pubkey[TOX_PUBLIC_KEY_SIZE];

char name[TOX_MAX_NAME_LENGTH 1];

};

struct Group {

};

struct Friend {

};

int NEW_STDIN_FILENO = STDIN_FILENO;

struct Request *requests = NULL;

struct Friend *friends = NULL;

struct Friend self;

struct Group *groups = NULL;

enum TALK_TYPE { TALK_TYPE_FRIEND, TALK_TYPE_GROUP, TALK_TYPE_COUNT, TALK_TYPE_NULL = UINT32_MAX };

uint32_t TalkingTo = TALK_TYPE_NULL;

/*******************************************************************************

*

* Utils

*

******************************************************************************/

#define RESIZE(key, size_key, length) \

if ((size_key) < (length 1)) { \

size_key = (length 1);\

key = calloc(1, size_key);\

}

#define LIST_FIND(_p, _condition) \

for (;*(_p) != NULL;_p = &((*_p)->next)) { \

if (_condition) { \

break;\

}\

}\

#define INDEX_TO_TYPE(idx) (idx % TALK_TYPE_COUNT)

#define INDEX_TO_NUM(idx) (idx / TALK_TYPE_COUNT)

#define GEN_INDEX(num,type) (num * TALK_TYPE_COUNT type)

bool str2uint(char *str, uint32_t *num) {

char *str_end;

long l = strtol(str,&str_end,10);

if (str_end == str || l < 0 ) return false;

*num = (uint32_t)l;

return true;

}

char* genmsg(struct ChatHist **pp, const char *fmt, ...) {

va_list va;

va_start(va, fmt);

va_list va2;

va_copy(va2, va);

size_t len = vsnprintf(NULL, 0, fmt, va2);

va_end(va2);

struct ChatHist *h = malloc(sizeof(struct ChatHist));

h->prev = NULL;

h->next = (*pp);

if (*pp) (*pp)->prev = h;

*pp = h;

h->msg = malloc(len 1);

vsnprintf(h->msg, len 1, fmt, va);

va_end(va);

return h->msg;

}

char* getftime(void) {

static char timebuf[64];

time_t tt = time(NULL);

struct tm *tm = localtime(&tt);

strftime(timebuf, sizeof(timebuf), "%H:%M:%S", tm);

return timebuf;

}

const char * connection_enum2text(TOX_CONNECTION conn) {

switch (conn) {

case TOX_CONNECTION_NONE:

return "Offline";

case TOX_CONNECTION_TCP:

return "Online(TCP)";

case TOX_CONNECTION_UDP:

return "Online(UDP)";

default:

return "UNKNOWN";

}

}

struct Friend *getfriend(uint32_t friend_num) {

struct Friend **p = &friends;

LIST_FIND(p, (*p)->friend_num == friend_num);

return *p;

}

struct Friend *addfriend(uint32_t friend_num) {

struct Friend *f = calloc(1, sizeof(struct Friend));

f->next = friends;

friends = f;

f->friend_num = friend_num;

f->connection = TOX_CONNECTION_NONE;

tox_friend_get_public_key(tox, friend_num, f->pubkey, NULL);

return f;

}

bool delfriend(uint32_t friend_num) {

struct Friend **p = &friends;

LIST_FIND(p, (*p)->friend_num == friend_num);

struct Friend *f = *p;

if (f) {

*p = f->next;

if (f->name) free(f->name);

if (f->status_message) free(f->status_message);

while (f->hist) {

struct ChatHist *tmp = f->hist;

f->hist = f->hist->next;

free(tmp);

}

free(f);

return 1;

}

return 0;

}

struct Group *addgroup(uint32_t group_num) {

struct Group *cf = calloc(1, sizeof(struct Group));

cf->next = groups;

groups = cf;

cf->group_num = group_num;

return cf;

}

bool delgroup(uint32_t group_num) {

struct Group **p = &groups;

LIST_FIND(p, (*p)->group_num == group_num);

struct Group *cf = *p;

if (cf) {

*p = cf->next;

if (cf->peers) free(cf->peers);

if (cf->title) free(cf->title);

while (cf->hist) {

struct ChatHist *tmp = cf->hist;

cf->hist = cf->hist->next;

free(tmp);

}

free(cf);

return 1;

}

return 0;

}

struct Group *getgroup(uint32_t group_num) {

struct Group **p = &groups;

LIST_FIND(p, (*p)->group_num == group_num);

return *p;

}

uint8_t *hex2bin(const char *hex)

{

size_t len = strlen(hex) / 2;

uint8_t *bin = malloc(len);

for (size_t i = 0; i < len; i, hex = 2) {

sscanf(hex, "%2hhx", &bin[i]);

}

return bin;

}

char *bin2hex(const uint8_t *bin, size_t length) {

char *hex = malloc(2*length 1);

char *saved = hex;

for (int i=0; i<length;i ,hex =2) {

sprintf(hex, "X",bin[i]);

}

return saved;

}

struct ChatHist ** get_current_histp(void) {

if (TalkingTo == TALK_TYPE_NULL) return NULL;

uint32_t num = INDEX_TO_NUM(TalkingTo);

switch (INDEX_TO_TYPE(TalkingTo)) {

case TALK_TYPE_FRIEND: {

struct Friend *f = getfriend(num);

if (f) return &f->hist;

break;

}

case TALK_TYPE_GROUP: {

struct Group *cf = getgroup(num);

if (cf) return &cf->hist;

break;

}

}

return NULL;

}

/*******************************************************************************

*

* Async REPL

*

******************************************************************************/

struct AsyncREPL {

};

struct termios saved_tattr;

struct AsyncREPL *async_repl;

void arepl_exit(void) {

tcsetattr(NEW_STDIN_FILENO, TCSAFLUSH, &saved_tattr);

}

void setup_arepl(void) {

if (!(isatty(STDIN_FILENO) && isatty(STDOUT_FILENO))) {

fputs("! stdout & stdin should be connected to tty", stderr);

exit(1);

}

async_repl = malloc(sizeof(struct AsyncREPL));

async_repl->nbuf = 0;

async_repl->nstack = 0;

async_repl->sz = LINE_MAX_SIZE;

async_repl->line = malloc(LINE_MAX_SIZE);

async_repl->prompt = malloc(LINE_MAX_SIZE);

strcpy(async_repl->prompt, CMD_PROMPT);

// stdin and stdout may share the same file obj,

// reopen stdin to avoid accidentally getting stdout modified.

char stdin_path[4080]; // 4080 is large enough for a path length for *nix system.

#ifdef F_GETPATH // macosx

if (fcntl(STDIN_FILENO, F_GETPATH, stdin_path) == -1) {

fputs("! fcntl get stdin filepath failed", stderr);

exit(1);

}

#else // linux

if (readlink("/proc/self/fd/0", stdin_path, sizeof(stdin_path)) == -1) {

fputs("! get stdin filename failed", stderr);

exit(1);

}

#endif

NEW_STDIN_FILENO = open(stdin_path, O_RDONLY);

if (NEW_STDIN_FILENO == -1) {

fputs("! reopen stdin failed",stderr);

exit(1);

}

close(STDIN_FILENO);

// Set stdin to Non-Blocking

int flags = fcntl(NEW_STDIN_FILENO, F_GETFL, 0);

fcntl(NEW_STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);

/* Set stdin to Non-Canonical terminal mode. */

struct termios tattr;

tcgetattr(NEW_STDIN_FILENO, &tattr);

saved_tattr = tattr; // save it to restore when exit

tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON. */

tattr.c_cc[VMIN] = 1;

tattr.c_cc[VTIME] = 0;

tcsetattr(NEW_STDIN_FILENO, TCSAFLUSH, &tattr);

atexit(arepl_exit);

}

void arepl_reprint(struct AsyncREPL *arepl) {

fputs(CODE_ERASE_LINE, stdout);

if (arepl->prompt) fputs(arepl->prompt, stdout);

if (arepl->nbuf > 0) printf("%.*s", arepl->nbuf, arepl->line);

if (arepl->nstack > 0) {

printf("%.*s",(int)arepl->nstack, arepl->line arepl->sz - arepl->nstack);

printf("\033[�",arepl->nstack); // move cursor

}

fflush(stdout);

}

#define _AREPL_CURSOR_LEFT() arepl->line[arepl->sz - ( arepl->nstack)] = arepl->line[--arepl->nbuf]

#define _AREPL_CURSOR_RIGHT() arepl->line[arepl->nbuf ] = arepl->line[arepl->sz - (arepl->nstack--)]

int arepl_readline(struct AsyncREPL *arepl, char c, char *line, size_t sz){

static uint32_t escaped = 0;

if (c == '\033') { // mark escape code

escaped = 1;

return 0;

}

if (escaped>0) escaped ;

switch (c) {

case '\n': {

int ret = snprintf(line, sz, "%.*s%.*s\n",(int)arepl->nbuf, arepl->line, (int)arepl->nstack, arepl->line arepl->sz - arepl->nstack);

arepl->nbuf = 0;

arepl->nstack = 0;

return ret;

}

case '\010': // C-h

case '\177': // Backspace

if (arepl->nbuf > 0) arepl->nbuf--;

break;

case '\025': // C-u

arepl->nbuf = 0;

break;

case '\013': // C-k Vertical Tab

arepl->nstack = 0;

break;

case '\001': // C-a

while (arepl->nbuf > 0) _AREPL_CURSOR_LEFT();

break;

case '\005': // C-e

while (arepl->nstack > 0) _AREPL_CURSOR_RIGHT();

break;

case '\002': // C-b

if (arepl->nbuf > 0) _AREPL_CURSOR_LEFT();

break;

case '\006': // C-f

if (arepl->nstack > 0) _AREPL_CURSOR_RIGHT();

break;

case '\027': // C-w: backward delete a word

while (arepl->nbuf>0 && arepl->line[arepl->nbuf-1] == ' ') arepl->nbuf--;

while (arepl->nbuf>0 && arepl->line[arepl->nbuf-1] != ' ') arepl->nbuf--;

break;

case 'D':

case 'C':

if (escaped == 3 && arepl->nbuf >= 1 && arepl->line[arepl->nbuf-1] == '[') { // arrow keys

arepl->nbuf--;

if (c == 'D' && arepl->nbuf > 0) _AREPL_CURSOR_LEFT(); // left arrow: \033[D

if (c == 'C' && arepl->nstack > 0) _AREPL_CURSOR_RIGHT(); // right arrow: \033[C

break;

}

// fall through to default case

default:

arepl->line[arepl->nbuf ] = c;

}

return 0;

}

/*******************************************************************************

*

* Tox Callbacks

*

******************************************************************************/

void friend_message_cb(Tox *tox, uint32_t friend_num, TOX_MESSAGE_TYPE type, const uint8_t *message,

size_t length, void *user_data)

{

struct Friend *f = getfriend(friend_num);

if (!f) return;

if (type != TOX_MESSAGE_TYPE_NORMAL) {

INFO("* receive MESSAGE ACTION type from %s, no supported", f->name);

return;

}

char *msg = genmsg(&f->hist, GUEST_MSG_PREFIX "%.*s", getftime(), f->name, (int)length, (char*)message);

if (GEN_INDEX(friend_num, TALK_TYPE_FRIEND) == TalkingTo) {

PRINT("%s", msg);

} else {

INFO("* receive message from %s, use `/go <contact_index>` to talk\n",f->name);

}

}

void friend_name_cb(Tox *tox, uint32_t friend_num, const uint8_t *name, size_t length, void *user_data) {

struct Friend *f = getfriend(friend_num);

if (f) {

f->name = realloc(f->name, length 1);

sprintf(f->name, "%.*s", (int)length, (char*)name);

if (GEN_INDEX(friend_num, TALK_TYPE_FRIEND) == TalkingTo) {

INFO("* Opposite changed name to %.*s", (int)length, (char*)name)

sprintf(async_repl->prompt, FRIEND_TALK_PROMPT, f->name);

}

}

}

void friend_status_message_cb(Tox *tox, uint32_t friend_num, const uint8_t *message, size_t length, void *user_data) {

struct Friend *f = getfriend(friend_num);

if (f) {

f->status_message = realloc(f->status_message, length 1);

sprintf(f->status_message, "%.*s",(int)length, (char*)message);

}

}

void friend_connection_status_cb(Tox *tox, uint32_t friend_num, TOX_CONNECTION connection_status, void *user_data)

{

struct Friend *f = getfriend(friend_num);

if (f) {

f->connection = connection_status;

INFO("* %s is %s", f->name, connection_enum2text(connection_status));

}

}

void friend_request_cb(Tox *tox, const uint8_t *public_key, const uint8_t *message, size_t length, void *user_data) {

INFO("* receive friend request(use `/accept` to see).");

struct Request *req = malloc(sizeof(struct Request));

req->id = 1 ((requests != NULL) ? requests->id : 0);

req->is_friend_request = true;

memcpy(req->userdata.friend.pubkey, public_key, TOX_PUBLIC_KEY_SIZE);

req->msg = malloc(length 1);

sprintf(req->msg, "%.*s", (int)length, (char*)message);

req->next = requests;

requests = req;

}

void self_connection_status_cb(Tox *tox, TOX_CONNECTION connection_status, void *user_data)

{

self.connection = connection_status;

INFO("* You are %s", connection_enum2text(connection_status));

}

void group_invite_cb(Tox *tox, uint32_t friend_num, TOX_CONFERENCE_TYPE type, const uint8_t *cookie, size_t length, void *user_data) {

struct Friend *f = getfriend(friend_num);

if (f) {

if (type == TOX_CONFERENCE_TYPE_AV) {

WARN("* %s invites you to an AV group, which has not been supported.", f->name);

return;

}

INFO("* %s invites you to a group(try `/accept` to see)",f->name);

struct Request *req = malloc(sizeof(struct Request));

req->id = 1 ((requests != NULL) ? requests->id : 0);

req->next = requests;

requests = req;

req->is_friend_request = false;

req->userdata.group.cookie = malloc(length);

memcpy(req->userdata.group.cookie, cookie, length),

req->userdata.group.length = length;

req->userdata.group.friend_num = friend_num;

int sz = snprintf(NULL, 0, "%s%s", "From ", f->name);

req->msg = malloc(sz 1);

sprintf(req->msg, "%s%s", "From ", f->name);

}

}

void group_title_cb(Tox *tox, uint32_t group_num, uint32_t peer_number, const uint8_t *title, size_t length, void *user_data) {

struct Group *cf = getgroup(group_num);

if (cf) {

cf->title = realloc(cf->title, length 1);

sprintf(cf->title, "%.*s", (int)length, (char*)title);

if (GEN_INDEX(group_num, TALK_TYPE_GROUP) == TalkingTo) {

INFO("* Group title changed to %s", cf->title);

sprintf(async_repl->prompt, GROUP_TALK_PROMPT, cf->title);

}

}

}

void group_message_cb(Tox *tox, uint32_t group_num, uint32_t peer_number, TOX_MESSAGE_TYPE type, const uint8_t *message, size_t length, void *user_data) {

struct Group *cf = getgroup(group_num);

if (!cf) return;

if (tox_conference_peer_number_is_ours(tox, group_num, peer_number, NULL)) return;

if (type != TOX_MESSAGE_TYPE_NORMAL) {

INFO("* receive MESSAGE ACTION type from group %s, no supported", cf->title);

return;

}

if (peer_number >= cf->peers_count) {

ERROR("! Unknown peer_number, peer_count:%zu, peer_number:%u", cf->peers_count, peer_number);

return;

}

struct GroupPeer *peer = &cf->peers[peer_number];

char *msg = genmsg(&cf->hist, GUEST_MSG_PREFIX "%.*s", getftime(), peer->name, (int)length, (char*)message);

if (GEN_INDEX(group_num, TALK_TYPE_GROUP) == TalkingTo) {

PRINT("%s", msg);

} else {

INFO("* receive group message from %s, in group %s",peer->name, cf->title);

}

}

void group_peer_list_changed_cb(Tox *tox, uint32_t group_num, void *user_data) {

struct Group *cf = getgroup(group_num);

if (!cf) return;

TOX_ERR_CONFERENCE_PEER_QUERY err;

uint32_t count = tox_conference_peer_count(tox, group_num, &err);

if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {

ERROR("get group peer count failed, errcode:%d",err);

return;

}

if (cf->peers) free(cf->peers);

cf->peers = calloc(count, sizeof(struct GroupPeer));

cf->peers_count = count;

for (int i=0;i<count;i ) {

struct GroupPeer *p = cf->peers i;

tox_conference_peer_get_name(tox, group_num, i, (uint8_t*)p->name, NULL);

tox_conference_peer_get_public_key(tox, group_num, i, p->pubkey,NULL);

}

}

void group_peer_name_cb(Tox *tox, uint32_t group_num, uint32_t peer_num, const uint8_t *name, size_t length, void *user_data) {

struct Group *cf = getgroup(group_num);

if (!cf || peer_num >= cf->peers_count) {

ERROR("! Unexpected group_num/peer_num in group_peer_name_cb");

return;

}

struct GroupPeer *p = &cf->peers[peer_num];

sprintf(p->name, "%.*s", (int)length, (char*)name);

}

/*******************************************************************************

*

* Tox Setup

*

******************************************************************************/

void create_tox(void)

{

struct Tox_Options *options = tox_options_new(NULL);

tox_options_set_start_port(options, PORT_RANGE_START);

tox_options_set_end_port(options, PORT_RANGE_END);

if (savedata_filename) {

FILE *f = fopen(savedata_filename, "rb");

if (f) {

fseek(f, 0, SEEK_END);

long fsize = ftell(f);

fseek(f, 0, SEEK_SET);

char *savedata = malloc(fsize);

fread(savedata, fsize, 1, f);

fclose(f);

tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);

tox_options_set_savedata_data(options, (uint8_t*)savedata, fsize);

tox = tox_new(options, NULL);

free(savedata);

}

}

if (!tox) tox = tox_new(options, NULL);

tox_options_free(options);

}

void init_friends(void) {

size_t sz = tox_self_get_friend_list_size(tox);

uint32_t *friend_list = malloc(sizeof(uint32_t) * sz);

tox_self_get_friend_list(tox, friend_list);

size_t len;

for (int i = 0;i<sz;i ) {

uint32_t friend_num = friend_list[i];

struct Friend *f = addfriend(friend_num);

len = tox_friend_get_name_size(tox, friend_num, NULL) 1;

f->name = calloc(1, len);

tox_friend_get_name(tox, friend_num, (uint8_t*)f->name, NULL);

len = tox_friend_get_status_message_size(tox, friend_num, NULL) 1;

f->status_message = calloc(1, len);

tox_friend_get_status_message(tox, friend_num, (uint8_t*)f->status_message, NULL);

tox_friend_get_public_key(tox, friend_num, f->pubkey, NULL);

}

free(friend_list);

// add self

self.friend_num = TALK_TYPE_NULL;

len = tox_self_get_name_size(tox) 1;

self.name = calloc(1, len);

tox_self_get_name(tox, (uint8_t*)self.name);

len = tox_self_get_status_message_size(tox) 1;

self.status_message = calloc(1, len);

tox_self_get_status_message(tox, (uint8_t*)self.status_message);

tox_self_get_public_key(tox, self.pubkey);

}

void update_savedata_file(void)

{

if (!(savedata_filename && savedata_tmp_filename)) return;

size_t size = tox_get_savedata_size(tox);

char *savedata = malloc(size);

tox_get_savedata(tox, (uint8_t*)savedata);

FILE *f = fopen(savedata_tmp_filename, "wb");

fwrite(savedata, size, 1, f);

fclose(f);

rename(savedata_tmp_filename, savedata_filename);

free(savedata);

}

void bootstrap(void)

{

for (size_t i = 0; i < sizeof(bootstrap_nodes)/sizeof(struct DHT_node); i ) {

uint8_t *bin = hex2bin(bootstrap_nodes[i].key_hex);

tox_bootstrap(tox, bootstrap_nodes[i].ip, bootstrap_nodes[i].port, bin, NULL);

free(bin);

}

}

void setup_tox(void)

{

create_tox();

init_friends();

bootstrap();

////// register callbacks

// self

tox_callback_self_connection_status(tox, self_connection_status_cb);

// friend

tox_callback_friend_request(tox, friend_request_cb);

tox_callback_friend_message(tox, friend_message_cb);

tox_callback_friend_name(tox, friend_name_cb);

tox_callback_friend_status_message(tox, friend_status_message_cb);

tox_callback_friend_connection_status(tox, friend_connection_status_cb);

// group

tox_callback_conference_invite(tox, group_invite_cb);

tox_callback_conference_title(tox, group_title_cb);

tox_callback_conference_message(tox, group_message_cb);

tox_callback_conference_peer_list_changed(tox, group_peer_list_changed_cb);

tox_callback_conference_peer_name(tox, group_peer_name_cb);

}

/*******************************************************************************

*

* Commands

*

******************************************************************************/

void command_help(int narg, char **args);

void command_guide(int narg, char **args) {

PRINT("This program is an minimal workable implementation of Tox client.");

PRINT("As it pursued simplicity at the cost of robustness and efficiency,");

PRINT("It should only be used for learning or playing with, instead of daily use.\n");

PRINT("Commands are any input lines with leading `/`,");

PRINT("Command args are seprated by blanks,");

PRINT("while some special commands may accept any-character string, like `/setname` and `/setstmsg`.\n");

PRINT("Use `/setname <YOUR NAME>` to set your name");

PRINT("Use `/info` to see your Name, Tox Id and Network Connection.");

PRINT("Use `/contacts` to list friends and groups, and use `/go <TARGET>` to talk to one of them.");

PRINT("Finally, use `/help` to get a list of available commands.\n");

PRINT("HAVE FUN!\n")

}

void _print_friend_info(struct Friend *f, bool is_self) {

PRINT("%-15s%s", "Name:", f->name);

if (is_self) {

uint8_t tox_id_bin[TOX_ADDRESS_SIZE];

tox_self_get_address(tox, tox_id_bin);

char *hex = bin2hex(tox_id_bin, sizeof(tox_id_bin));

PRINT("%-15s%s","Tox ID:", hex);

free(hex);

}

char *hex = bin2hex(f->pubkey, sizeof(f->pubkey));

PRINT("%-15s%s","Public Key:", hex);

free(hex);

PRINT("%-15s%s", "Status Msg:",f->status_message);

PRINT("%-15s%s", "Network:",connection_enum2text(f->connection));

}

void command_info(int narg, char **args) {

if (narg == 0) { // self

_print_friend_info(&self, true);

return;

}

uint32_t contact_idx;

if (!str2uint(args[0],&contact_idx)) goto FAIL;

uint32_t num = INDEX_TO_NUM(contact_idx);

switch (INDEX_TO_TYPE(contact_idx)) {

case TALK_TYPE_FRIEND: {

struct Friend *f = getfriend(num);

if (f) {

_print_friend_info(f, false);

return;

}

break;

}

case TALK_TYPE_GROUP: {

struct Group *cf = getgroup(num);

if (cf) {

PRINT("GROUP TITLE:\t%s",cf->title);

PRINT("PEER COUNT:\t%zu", cf->peers_count);

PRINT("Peers:");

for (int i=0;i<cf->peers_count;i ){

PRINT("\t%s",cf->peers[i].name);

}

return;

}

break;

}

}

FAIL:

WARN("^ Invalid contact index");

}

void command_setname(int narg, char **args) {

char *name = args[0];

size_t len = strlen(name);

TOX_ERR_SET_INFO err;

tox_self_set_name(tox, (uint8_t*)name, strlen(name), &err);

if (err != TOX_ERR_SET_INFO_OK) {

ERROR("! set name failed, errcode:%d", err);

return;

}

self.name = realloc(self.name, len 1);

strcpy(self.name, name);

}

void command_setstmsg(int narg, char **args) {

char *status = args[0];

size_t len = strlen(status);

TOX_ERR_SET_INFO err;

tox_self_set_status_message(tox, (uint8_t*)status, strlen(status), &err);

if (err != TOX_ERR_SET_INFO_OK) {

ERROR("! set status message failed, errcode:%d", err);

return;

}

self.status_message = realloc(self.status_message, len 1);

strcpy(self.status_message, status);

}

void command_add(int narg, char **args) {

char *hex_id = args[0];

char *msg = "";

if (narg > 1) msg = args[1];

uint8_t *bin_id = hex2bin(hex_id);

TOX_ERR_FRIEND_ADD err;

uint32_t friend_num = tox_friend_add(tox, bin_id, (uint8_t*)msg, strlen(msg), &err);

free(bin_id);

if (err != TOX_ERR_FRIEND_ADD_OK) {

ERROR("! add friend failed, errcode:%d",err);

return;

}

addfriend(friend_num);

}

void command_del(int narg, char **args) {

uint32_t contact_idx;

if (!str2uint(args[0], &contact_idx)) goto FAIL;

uint32_t num = INDEX_TO_NUM(contact_idx);

switch (INDEX_TO_TYPE(contact_idx)) {

case TALK_TYPE_FRIEND:

if (delfriend(num)) {

tox_friend_delete(tox, num, NULL);

return;

}

break;

case TALK_TYPE_GROUP:

if (delgroup(num)) {

tox_conference_delete(tox, num, NULL);

return;

}

break;

}

FAIL:

WARN("^ Invalid contact index");

}

void command_contacts(int narg, char **args) {

struct Friend *f = friends;

PRINT("#Friends(conctact_index|name|connection|status message):\n");

for (;f != NULL; f = f->next) {

PRINT("= .15s .12s %s",GEN_INDEX(f->friend_num, TALK_TYPE_FRIEND), f->name, connection_enum2text(f->connection), f->status_message);

}

struct Group *cf = groups;

PRINT("\n#Groups(contact_index|count of peers|name):\n");

for (;cf != NULL; cf = cf->next) {

PRINT("= d %s",GEN_INDEX(cf->group_num, TALK_TYPE_GROUP), tox_conference_peer_count(tox, cf->group_num, NULL), cf->title);

}

}

void command_save(int narg, char **args) {

update_savedata_file();

}

void command_go(int narg, char **args) {

if (narg == 0) {

TalkingTo = TALK_TYPE_NULL;

strcpy(async_repl->prompt, CMD_PROMPT);

return;

}

uint32_t contact_idx;

if (!str2uint(args[0], &contact_idx)) goto FAIL;

uint32_t num = INDEX_TO_NUM(contact_idx);

switch (INDEX_TO_TYPE(contact_idx)) {

case TALK_TYPE_FRIEND: {

struct Friend *f = getfriend(num);

if (f) {

TalkingTo = contact_idx;

sprintf(async_repl->prompt, FRIEND_TALK_PROMPT, f->name);

return;

}

break;

}

case TALK_TYPE_GROUP: {

struct Group *cf = getgroup(num);

if (cf) {

TalkingTo = contact_idx;

sprintf(async_repl->prompt, GROUP_TALK_PROMPT, cf->title);

return;

}

break;

}

}

FAIL:

WARN("^ Invalid contact index");

}

void command_history(int narg, char **args) {