StarMirror/toxcore
1
0
Fork 0
mirror of https://github.com/irungentoo/toxcore.git synced 2024-03-22 13:30:51 +08:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' of git://github.com/irungentoo/ProjectTox-Core

Browse Source
This commit is contained in:
charmlesscoin 2013-08-06 20:58:42 -04:00
commit c644ccd287
18 changed files with 804 additions and 527 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
cmake/FindLIBCONFIG.cmake
View File

@ -5,7 +5,12 @@
# LIBCONFIG_FOUND
#
FIND_PATH(LIBCONFIG_INCLUDE_DIR NAMES libconfig.h)
if (UNIX)
find_package(PkgConfig QUIET)
pkg_check_modules(_LIBCONFIG QUIET libconfig)
endif ()
FIND_PATH(LIBCONFIG_INCLUDE_DIR NAMES libconfig.h HINTS ${_LIBCONFIG_INCLUDEDIR})
FIND_LIBRARY(LIBCONFIG_LIBRARY NAMES config)

142
core/DHT.c
View File

@ -24,6 +24,7 @@
/*----------------------------------------------------------------------------------*/
#include "DHT.h"
#include "packets.h"
#include "ping.h"
/* maximum number of clients stored per friend. */
@ -351,7 +352,7 @@ static int replace_good( Client_data * list,
/* Attempt to add client with ip_port and client_id to the friends client list
* and close_clientlist
*/
static void addto_lists(IP_Port ip_port, uint8_t * client_id)
void addto_lists(IP_Port ip_port, uint8_t * client_id)
{
uint32_t i;
@ -472,71 +473,6 @@ static uint64_t add_gettingnodes(IP_Port ip_port)
return 0;
}
/* send a ping request, only works if none has been sent to that ip/port
* in the last 5 seconds.
*/
static int pingreq(IP_Port ip_port, uint8_t * public_key)
{
/* check if packet is gonna be sent to ourself */
if(id_equal(public_key, self_public_key) || is_pinging(ip_port, 0))
return 1;
uint64_t ping_id = add_ping(ip_port);
if(ping_id == 0)
return 1;
uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING];
uint8_t encrypt[sizeof(ping_id) + ENCRYPTION_PADDING];
uint8_t nonce[crypto_box_NONCEBYTES];
random_nonce(nonce);
int len = encrypt_data( public_key,
self_secret_key,
nonce,
(uint8_t *)&ping_id,
sizeof(ping_id),
encrypt );
if(len != sizeof(ping_id) + ENCRYPTION_PADDING)
return -1;
data[0] = 0;
memcpy(data + 1, self_public_key, CLIENT_ID_SIZE);
memcpy(data + 1 + CLIENT_ID_SIZE, nonce, crypto_box_NONCEBYTES);
memcpy(data + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, encrypt, len);
return sendpacket(ip_port, data, sizeof(data));
}
/* send a ping response */
static int pingres(IP_Port ip_port, uint8_t * public_key, uint64_t ping_id)
{
/* check if packet is gonna be sent to ourself */
if(id_equal(public_key, self_public_key))
return 1;
uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING];
uint8_t encrypt[sizeof(ping_id) + ENCRYPTION_PADDING];
uint8_t nonce[crypto_box_NONCEBYTES];
random_nonce(nonce);
int len = encrypt_data( public_key,
self_secret_key, nonce,
(uint8_t *)&ping_id,
sizeof(ping_id),
encrypt );
if(len != sizeof(ping_id) + ENCRYPTION_PADDING)
return -1;
data[0] = 1;
memcpy(data + 1, self_public_key, CLIENT_ID_SIZE);
memcpy(data + 1 + CLIENT_ID_SIZE, nonce, crypto_box_NONCEBYTES);
memcpy(data + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES, encrypt, len);
return sendpacket(ip_port, data, sizeof(data));
}
/* send a getnodes request */
static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id)
{
@ -618,62 +554,6 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id,
return sendpacket(ip_port, data, 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + len);
}
/* Packet handling functions, one to handle each types of packets we receive
* Returns 0 if handled correctly, 1 if packet is bad.
*/
static int handle_pingreq(uint8_t * packet, uint32_t length, IP_Port source)
{
uint64_t ping_id;
if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING)
return 1;
/* check if packet is from ourself. */
if(id_equal(packet + 1, self_public_key))
return 1;
int len = decrypt_data( packet + 1,
self_secret_key,
packet + 1 + CLIENT_ID_SIZE,
packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
sizeof(ping_id) + ENCRYPTION_PADDING,
(uint8_t *)&ping_id );
if(len != sizeof(ping_id))
return 1;
pingres(source, packet + 1, ping_id);
pingreq(source, packet + 1); /* TODO: make this smarter? */
return 0;
}
static int handle_pingres(uint8_t * packet, uint32_t length, IP_Port source)
{
uint64_t ping_id;
if(length != 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING)
return 1;
/* check if packet is from ourself. */
if(id_equal(packet + 1, self_public_key))
return 1;
int len = decrypt_data( packet + 1,
self_secret_key,
packet + 1 + CLIENT_ID_SIZE,
packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
sizeof(ping_id) + ENCRYPTION_PADDING,
(uint8_t *)&ping_id );
if(len != sizeof(ping_id))
return 1;
if(is_pinging(source, ping_id)) {
addto_lists(source, packet + 1);
return 0;
}
return 1;
}
static int handle_getnodes(uint8_t * packet, uint32_t length, IP_Port source)
{
uint64_t ping_id;
@ -701,7 +581,7 @@ static int handle_getnodes(uint8_t * packet, uint32_t length, IP_Port source)
memcpy(&ping_id, plain, sizeof(ping_id));
sendnodes(source, packet + 1, plain + sizeof(ping_id), ping_id);
pingreq(source, packet + 1); /* TODO: make this smarter? */
send_ping_request(source, (clientid_t*) (packet + 1)); /* TODO: make this smarter? */
return 0;
}
@ -741,7 +621,7 @@ static int handle_sendnodes(uint8_t * packet, uint32_t length, IP_Port source)
uint32_t i;
for(i = 0; i < num_nodes; ++i) {
pingreq(nodes_list[i].ip_port, nodes_list[i].client_id);
send_ping_request(nodes_list[i].ip_port, (clientid_t*) &nodes_list[i].client_id);
returnedip_ports(nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1);
}
@ -831,8 +711,8 @@ static void doDHTFriends(void)
/* if node is not dead. */
if (!is_timeout(temp_time, friends_list[i].client_list[j].timestamp, Kill_NODE_TIMEOUT)) {
if ((friends_list[i].client_list[j].last_pinged + PING_INTERVAL) <= temp_time) {
pingreq( friends_list[i].client_list[j].ip_port,
friends_list[i].client_list[j].client_id );
send_ping_request( friends_list[i].client_list[j].ip_port,
(clientid_t*) &friends_list[i].client_list[j].client_id );
friends_list[i].client_list[j].last_pinged = temp_time;
}
/* if node is good. */
@ -869,8 +749,8 @@ static void doClose(void)
/* if node is not dead. */
if (!is_timeout(temp_time, close_clientlist[i].timestamp, Kill_NODE_TIMEOUT)) {
if ((close_clientlist[i].last_pinged + PING_INTERVAL) <= temp_time) {
pingreq( close_clientlist[i].ip_port,
close_clientlist[i].client_id );
send_ping_request( close_clientlist[i].ip_port,
(clientid_t*) &close_clientlist[i].client_id );
close_clientlist[i].last_pinged = temp_time;
}
/* if node is good. */
@ -1151,7 +1031,7 @@ static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t
/*TODO: improve port guessing algorithm*/
uint16_t port = port_list[(i/2) % numports] + (i/(2*numports))*((i % 2) ? -1 : 1);
IP_Port pinging = {ip, htons(port)};
pingreq(pinging, friends_list[friend_num].client_id);
send_ping_request(pinging, (clientid_t*) &friends_list[friend_num].client_id);
}
friends_list[friend_num].punching_index = i;
}
@ -1198,10 +1078,10 @@ int DHT_handlepacket(uint8_t * packet, uint32_t length, IP_Port source)
{
switch (packet[0]) {
case 0:
return handle_pingreq(packet, length, source);
return handle_ping_request(packet, length, source);
case 1:
return handle_pingres(packet, length, source);
return handle_ping_response(packet, length, source);
case 2:
return handle_getnodes(packet, length, source);

2
core/DHT.h
View File

@ -104,6 +104,8 @@ int DHT_load(uint8_t *data, uint32_t size);
returns 1 if we are */
int DHT_isconnected();
void addto_lists(IP_Port ip_port, uint8_t * client_id);
#ifdef __cplusplus
}
#endif

4
core/LAN_discovery.c
View File

@ -70,6 +70,10 @@ static uint32_t get_broadcast(void)
}
}
close(sock);
if(sock_holder == NULL) {
perror("[!] no broadcast device found");
return 0;
}
return sock_holder->sin_addr.s_addr;
}

6
core/Messenger.c
View File

@ -116,7 +116,7 @@ int m_addfriend(uint8_t *client_id, uint8_t *data, uint16_t length)
return FAERR_ALREADYSENT;
uint32_t i;
for (i = 0; i <= numfriends && i <= MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
for (i = 0; i < numfriends && i < MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
if(friendlist[i].status == NOFRIEND) {
DHT_addfriend(client_id);
friendlist[i].status = FRIEND_ADDED;
@ -141,7 +141,7 @@ int m_addfriend_norequest(uint8_t * client_id)
if (getfriend_id(client_id) != -1)
return -1;
uint32_t i;
for (i = 0; i <= numfriends && i <= MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
for (i = 0; i < numfriends && i < MAX_NUM_FRIENDS; ++i) { /*TODO: dynamic memory allocation to allow for more than MAX_NUM_FRIENDS friends */
if(friendlist[i].status == NOFRIEND) {
DHT_addfriend(client_id);
friendlist[i].status = FRIEND_REQUESTED;
@ -352,7 +352,7 @@ static int send_userstatus(int friendnumber, uint8_t * status, uint16_t length)
memcpy(thepacket + 2, status, length);
thepacket[0] = PACKET_ID_USERSTATUS;
thepacket[1] = self_userstatus_kind;
int written = write_cryptpacket(friendlist[friendnumber].crypt_connection_id, thepacket, length + 1);
int written = write_cryptpacket(friendlist[friendnumber].crypt_connection_id, thepacket, length + 2);
free(thepacket);
return written;
}

37
core/packets.h Normal file
View File

@ -0,0 +1,37 @@
/*
* packet.h -- Packet structure
*
* This file is donated to the Tox Project.
* Copyright 2013 plutooo
*/
typedef struct {
uint8_t id[CLIENT_ID_SIZE];
} __attribute__((packed)) clientid_t;
typedef enum {
PACKET_PING_REQ = 0,
PACKET_PING_RES = 1
} packetid_t;
// Ping packet
typedef struct {
uint8_t magic;
clientid_t client_id;
uint8_t nonce[crypto_box_NONCEBYTES];
uint64_t ping_id;
uint8_t padding[ENCRYPTION_PADDING];
} __attribute__((packed)) pingreq_t;
// Pong packet
typedef struct {
uint8_t magic;
clientid_t client_id;
uint8_t nonce[crypto_box_NONCEBYTES];
uint64_t ping_id;
uint8_t padding[ENCRYPTION_PADDING];
} __attribute__((packed)) pingres_t;

119
core/ping.c
View File

@ -8,6 +8,9 @@
#include <stdbool.h>
#include <stdint.h>
#include "DHT.h"
#include "net_crypto.h"
#include "packets.h"
#include "network.h"
#include "util.h"
@ -23,7 +26,9 @@ typedef struct {
static pinged_t pings[PING_NUM_MAX];
static size_t num_pings;
static size_t pos_pings;
static clientid_t* self_id = (clientid_t*) &self_public_key;
extern uint8_t self_secret_key[crypto_box_SECRETKEYBYTES]; // DHT.c
void init_ping()
{
@ -51,9 +56,10 @@ static void remove_timeouts() // O(n)
new_num--;
}
// Break here because list is sorted.
else
else {
break;
}
}
num_pings = new_num;
pos_pings = new_pos % PING_NUM_MAX;
@ -94,6 +100,7 @@ bool is_pinging(IP_Port ipp, uint64_t ping_id) // O(n) TODO: replace this with
for (i=0; i<num_pings; i++) {
id = (pos_pings + i) % PING_NUM_MAX;
// ping_id = 0 means match any id
if ((ipp_eq(pings[id].ipp, ipp) || ipp.ip.i == 0) && (pings[id].id == ping_id || ping_id == 0)) {
return true;
}
@ -101,3 +108,113 @@ bool is_pinging(IP_Port ipp, uint64_t ping_id) // O(n) TODO: replace this with
return false;
}
int send_ping_request(IP_Port ipp, clientid_t* client_id)
{
pingreq_t pk;
int rc;
uint64_t ping_id;
if (is_pinging(ipp, 0) || id_eq(client_id, self_id))
return 1;
// Generate random ping_id
ping_id = add_ping(ipp);
pk.magic = PACKET_PING_REQ;
id_cpy(&pk.client_id, self_id); // Our pubkey
random_nonce((uint8_t*) &pk.nonce); // Generate random nonce
// Encrypt ping_id using recipient privkey
rc = encrypt_data((uint8_t*) client_id,
self_secret_key,
(uint8_t*) &pk.nonce,
(uint8_t*) &ping_id, sizeof(ping_id),
(uint8_t*) &pk.ping_id);
if (rc != sizeof(ping_id) + ENCRYPTION_PADDING)
return 1;
return sendpacket(ipp, (uint8_t*) &pk, sizeof(pk));
}
int send_ping_response(IP_Port ipp, clientid_t* client_id, uint64_t ping_id)
{
pingres_t pk;
int rc;
if (id_eq(client_id, self_id))
return 1;
pk.magic = PACKET_PING_RES;
id_cpy(&pk.client_id, self_id); // Our pubkey
random_nonce((uint8_t*) &pk.nonce); // Generate random nonce
// Encrypt ping_id using recipient privkey
rc = encrypt_data((uint8_t*) client_id,
self_secret_key,
(uint8_t*) &pk.nonce,
(uint8_t*) &ping_id, sizeof(ping_id),
(uint8_t*) &pk.ping_id);
if (rc != sizeof(ping_id) + ENCRYPTION_PADDING)
return 1;
return sendpacket(ipp, (uint8_t*) &pk, sizeof(pk));
}
int handle_ping_request(uint8_t* packet, uint32_t length, IP_Port source)
{
pingreq_t* p = (pingreq_t*) packet;
int rc;
uint64_t ping_id;
if (length != sizeof(pingreq_t) || id_eq(&p->client_id, self_id))
return 1;
// Decrypt ping_id
rc = decrypt_data((uint8_t*) &p->client_id,
self_secret_key,
(uint8_t*) &p->nonce,
(uint8_t*) &p->ping_id,
sizeof(ping_id) + ENCRYPTION_PADDING,
(uint8_t*) &ping_id);
if (rc != sizeof(ping_id))
return 1;
// Send response
send_ping_response(source, &p->client_id, ping_id);
send_ping_request(source, &p->client_id); // Make this smarter?
return 0;
}
int handle_ping_response(uint8_t* packet, uint32_t length, IP_Port source)
{
pingres_t* p = (pingres_t*) packet;
int rc;
uint64_t ping_id;
if (length != sizeof(pingres_t) || id_eq(&p->client_id, self_id))
return 1;
// Decrypt ping_id
rc = decrypt_data((uint8_t*) &p->client_id,
self_secret_key,
(uint8_t*) &p->nonce,
(uint8_t*) &p->ping_id,
sizeof(ping_id) + ENCRYPTION_PADDING,
(uint8_t*) &ping_id);
if (rc != sizeof(ping_id))
return 1;
// Make sure ping_id is correct
if(!is_pinging(source, ping_id))
return 1;
// Associate source ip with client_id
addto_lists(source, (uint8_t*) &p->client_id);
return 0;
}

5
core/ping.h
View File

@ -10,4 +10,7 @@
void init_ping();
uint64_t add_ping(IP_Port ipp);
bool is_pinging(IP_Port ipp, uint64_t ping_id);
int send_ping_request(IP_Port ipp, clientid_t* client_id);
int send_ping_response(IP_Port ipp, clientid_t* client_id, uint64_t ping_id);
int handle_ping_request(uint8_t* packet, uint32_t length, IP_Port source);
int handle_ping_response(uint8_t* packet, uint32_t length, IP_Port source);

13
core/util.c
View File

@ -9,7 +9,8 @@
#include <stdint.h>
#include <stdbool.h>
#include "network.h"
#include "DHT.h"
#include "packets.h"
uint64_t now()
{
@ -32,3 +33,13 @@ bool ipp_eq(IP_Port a, IP_Port b)
{
return (a.ip.i == b.ip.i) && (a.port == b.port);
}
bool id_eq(clientid_t* dest, clientid_t* src)
{
return memcmp(dest, src, sizeof(clientid_t)) == 0;
}
void id_cpy(clientid_t* dest, clientid_t* src)
{
memcpy(dest, src, sizeof(clientid_t));
}

3
core/util.h
View File

@ -8,3 +8,6 @@
uint64_t now();
uint64_t random_64b();
bool ipp_eq(IP_Port a, IP_Port b);
bool id_eq(clientid_t* dest, clientid_t* src);
void id_cpy(clientid_t* dest, clientid_t* src);

12
testing/misc_tools.c
View File

@ -25,7 +25,11 @@
#include <string.h>
#include <stdlib.h>
#include <stdio.h> /* for sscanf */
#include <stdio.h>
#ifdef DEBUG
#include <assert.h>
#endif // DEBUG
/* TODO: rewrite */
unsigned char * hex_string_to_bin(char hex_string[])
@ -39,3 +43,9 @@ unsigned char * hex_string_to_bin(char hex_string[])
return val;
}

140
testing/misc_tools.h
View File

@ -26,4 +26,144 @@
unsigned char * hex_string_to_bin(char hex_string[]);
/* WARNING(msg) takes a printf()-styled string and prints it
* with some additional details.
* ERROR(exit_status, msg) does the same thing as WARNING(), but
* also exits the program with the given exit status.
* Examples:
* WARNING("<insert warning message here>");
* int exit_status = 2;
* ERROR(exit_status, "exiting with status %i", exit_status);
*/
#ifdef DEBUG
#include <assert.h>
#include <stdio.h>
#include <string.h>
#define DEBUG_PRINT(str, ...) do { \
char msg[1000]; \
sprintf(msg, "%s(): line %d (file %s): %s%%c\n", __FUNCTION__, __LINE__, __FILE__, str); \
fprintf(stderr, msg, __VA_ARGS__); \
} while (0)
#define WARNING(...) do { \
fprintf(stderr, "warning in "); \
DEBUG_PRINT(__VA_ARGS__, ' '); \
} while (0)
#define ERROR(exit_status, ...) do { \
fprintf(stderr, "error in "); \
DEBUG_PRINT(__VA_ARGS__, ' '); \
exit(exit_status); \
} while (0)
#else
#define WARNING(...)
#define ERROR(...)
#endif // DEBUG
/************************Linked List***********************
* This is a simple linked list implementation, very similar
* to Linux kernel's /include/linux/list.h (which we can't
* use because Tox is GPLv3 and Linux is GPLv2.)
*
* TODO: Make the lists easier to use with some sweat pre-
* processor syntactic sugar.
**********************************************************/
/* Example usage
This sample program makes a new struct which contains a
character and a tox_list_t. It then prompts a user for
input until he enters q or e. It then adds each character
to the list, and uses a special for loop to print them.
It then removes all the 'z' characters, and prints the list
again.
//Notice that the data to be put in the list *contains* tox_list_t;
//usually, this is the other way around!
typedef struct tox_string {
char c;
tox_list_t tox_lst; //Notice that tox_lst is *NOT* a pointer.
} tox_string_t;
int main()
{
tox_list_t head;
tox_list_new(&head); //initialize head
//input a new character, until user enters q or e
char c = '\0';
while (c != 'q' && c != 'e') {
scanf("%c", &c);
tox_string_t* tmp = malloc(sizeof(tox_string_t));
tmp->c = c;
tox_list_add(&head, &tmp->tox_lst); //add it to the list
}
TOX_LIST_FOR_EACH() takes a struct tox_list and a name for a temporary pointer to use in the loop.
TOX_LIST_GET_VALUE() uses magic to return an instance of a structure that contains tox_list_t.
You have to give it a temporary tox_string_t, name of tox_list_t member inside our structure (tox_lst),
and the type of structure to return.
TOX_LIST_FOR_EACH(head, tmp)
printf("%c", TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c);
TOX_LIST_FOR_EACH(head, tmp) {
if (TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c == 'z') {
//If you delete tmp, you have to quit the loop, or it will go on infinitly.
//This will be fixed later on.
tox_list_remove(tmp);
break;
}
}
printf("\n");
TOX_LIST_FOR_EACH(head, tmp)
printf("%c", TOX_LIST_GET_VALUE(*tmp, tox_lst, tox_string_t).c);
return 0;
}
*/
#define MEMBER_OFFSET(var_name_in_parent, parent_type) \
(&(((parent_type*)0)->var_name_in_parent))
#define GET_PARENT(var, var_name_in_parent, parent_type) \
(*((parent_type*)((uint64_t)(&(var)) - (uint64_t)(MEMBER_OFFSET(var_name_in_parent, parent_type)))))
#define TOX_LIST_FOR_EACH(lst, tmp_name) \
for (tox_list_t* tmp_name = lst.next; tmp_name != &lst; tmp_name = tmp_name->next)
#define TOX_LIST_GET_VALUE(tmp_name, name_in_parent, parent_type) GET_PARENT(tmp_name, name_in_parent, parent_type)
typedef struct tox_list {
struct tox_list *prev, *next;
} tox_list_t;
/* Returns a new tox_list_t. */
static inline void tox_list_new(tox_list_t* lst) {
lst->prev = lst->next = lst;
}
/* Inserts a new tox_lst after lst and returns it. */
static inline void tox_list_add(tox_list_t* lst, tox_list_t* new_lst) {
tox_list_new(new_lst);
new_lst->next = lst->next;
new_lst->next->prev = new_lst;
lst->next = new_lst;
new_lst->prev = lst;
}
static inline void tox_list_remove(tox_list_t* lst) {
#ifdef DEBUG /* TODO: check how debugging is done in Tox. */
assert(lst->next != lst && lst->prev != lst);
#endif
lst->prev->next = lst->next;
lst->next->prev = lst->prev;
}
#endif // MISC_TOOLS_H

2
testing/nTox.c
View File

@ -410,6 +410,8 @@ void load_key(char *path)
}
}
if(fclose(data_file) < 0)
perror("[!] fclose failed");
return;
FILE_ERROR:

120
testing/toxic/chat.c
View File

@ -16,41 +16,39 @@
typedef struct {
int friendnum;
char line[256];
size_t pos;
WINDOW* history;
WINDOW* linewin;
} ChatContext;
extern void fix_name(uint8_t* name);
void print_help(ChatContext* self);
void execute(ToxWindow* self, ChatContext* ctx, char* cmd);
extern int active_window;
static void chat_onMessage(ToxWindow* self, int num, uint8_t* msg, uint16_t len) {
ChatContext* ctx = (ChatContext*) self->x;
extern void del_window(ToxWindow *w, int f_num);
extern void fix_name(uint8_t *name);
void print_help(ChatContext *self);
void execute(ToxWindow *self, ChatContext *ctx, char *cmd);
static void chat_onMessage(ToxWindow *self, int num, uint8_t *msg, uint16_t len)
{
ChatContext *ctx = (ChatContext*) self->x;
uint8_t nick[MAX_NAME_LENGTH] = {0};
time_t now;
time(&now);
struct tm * timeinfo;
timeinfo = localtime(&now);
if(ctx->friendnum != num)
if (ctx->friendnum != num)
return;
getname(num, (uint8_t*) &nick);
msg[len-1] = '\0';
nick[MAX_NAME_LENGTH-1] = '\0';
fix_name(msg);
fix_name(nick);
wattron(ctx->history, COLOR_PAIR(2));
wprintw(ctx->history, "%02d:%02d:%02d ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
wprintw(ctx->history, "[%02d:%02d:%02d] ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
wattroff(ctx->history, COLOR_PAIR(2));
wattron(ctx->history, COLOR_PAIR(4));
wprintw(ctx->history, "%s: ", nick);
@ -62,15 +60,14 @@ static void chat_onMessage(ToxWindow* self, int num, uint8_t* msg, uint16_t len)
flash();
}
static void chat_onNickChange(ToxWindow* self, int num, uint8_t* nick, uint16_t len) {
ChatContext* ctx = (ChatContext*) self->x;
if(ctx->friendnum != num)
static void chat_onNickChange(ToxWindow *self, int num, uint8_t *nick, uint16_t len)
{
ChatContext *ctx = (ChatContext*) self->x;
if (ctx->friendnum != num)
return;
nick[len-1] = '\0';
fix_name(nick);
snprintf(self->title, sizeof(self->title), "[%s (%d)]", nick, num);
wattron(ctx->history, COLOR_PAIR(3));
@ -78,7 +75,8 @@ static void chat_onNickChange(ToxWindow* self, int num, uint8_t* nick, uint16_t
wattroff(ctx->history, COLOR_PAIR(3));
}
static void chat_onStatusChange(ToxWindow* self, int num, uint8_t* status, uint16_t len) {
static void chat_onStatusChange(ToxWindow *self, int num, uint8_t *status, uint16_t len)
{
}
@ -87,45 +85,43 @@ int string_is_empty(char *string)
{
int rc = 0;
char *copy = strdup(string);
rc = ((strtok(copy, " ") == NULL) ? 1:0);
free(copy);
return rc;
}
static void chat_onKey(ToxWindow* self, int key) {
ChatContext* ctx = (ChatContext*) self->x;
static void chat_onKey(ToxWindow *self, int key)
{
ChatContext *ctx = (ChatContext*) self->x;
time_t now;
time(&now);
struct tm * timeinfo;
timeinfo = localtime(&now);
/* PRINTABLE characters: Add to line */
if(isprint(key)) {
if(ctx->pos != sizeof(ctx->line)-1) {
/* Add printable characters to line */
if (isprint(key)) {
if (ctx->pos != sizeof(ctx->line)-1) {
ctx->line[ctx->pos++] = key;
ctx->line[ctx->pos] = '\0';
}
}
/* RETURN key: Execute command or print line */
else if(key == '\n') {
else if (key == '\n') {
if (ctx->line[0] == '/')
execute(self, ctx, ctx->line);
else {
if(!string_is_empty(ctx->line)) {
if (!string_is_empty(ctx->line)) {
/* make sure the string has at least non-space character */
wattron(ctx->history, COLOR_PAIR(2));
wprintw(ctx->history, "%02d:%02d:%02d ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
wprintw(ctx->history, "[%02d:%02d:%02d] ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
wattroff(ctx->history, COLOR_PAIR(2));
wattron(ctx->history, COLOR_PAIR(1));
wprintw(ctx->history, "you: ", ctx->line);
wattroff(ctx->history, COLOR_PAIR(1));
wprintw(ctx->history, "%s\n", ctx->line);
}
if(m_sendmessage(ctx->friendnum, (uint8_t*) ctx->line, strlen(ctx->line)+1) < 0) {
if (m_sendmessage(ctx->friendnum, (uint8_t*) ctx->line, strlen(ctx->line)+1) < 0) {
wattron(ctx->history, COLOR_PAIR(3));
wprintw(ctx->history, " * Failed to send message.\n");
wattroff(ctx->history, COLOR_PAIR(3));
@ -136,29 +132,32 @@ static void chat_onKey(ToxWindow* self, int key) {
}
/* BACKSPACE key: Remove one character from line */
else if(key == 0x107 || key == 0x8 || key == 0x7f) {
if(ctx->pos != 0) {
else if (key == 0x107 || key == 0x8 || key == 0x7f) {
if (ctx->pos != 0) {
ctx->line[--ctx->pos] = '\0';
}
}
}
void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
void execute(ToxWindow *self, ChatContext *ctx, char *cmd)
{
if (!strcmp(cmd, "/clear") || !strcmp(cmd, "/c")) {
wclear(self->window);
wclear(ctx->history);
}
else if (!strcmp(cmd, "/help") || !strcmp(cmd, "/h"))
print_help(ctx);
else if (!strcmp(cmd, "/quit") || !strcmp(cmd, "/exit") || !strcmp(cmd, "/q")) {
endwin();
exit(0);
}
else if (!strncmp(cmd, "/status ", strlen("/status "))) {
char* msg;
char *msg;
msg = strchr(cmd, ' ');
if(msg == NULL) {
if (msg == NULL) {
wprintw(ctx->history, "Invalid syntax.\n");
return;
}
@ -166,10 +165,11 @@ void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
m_set_userstatus(USERSTATUS_KIND_RETAIN, (uint8_t*) msg, strlen(msg)+1);
wprintw(ctx->history, "Status set to: %s\n", msg);
}
else if (!strncmp(cmd, "/nick ", strlen("/nick "))) {
char* nick;
char *nick;
nick = strchr(cmd, ' ');
if(nick == NULL) {
if (nick == NULL) {
wprintw(ctx->history, "Invalid syntax.\n");
return;
}
@ -177,7 +177,8 @@ void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
setname((uint8_t*) nick, strlen(nick)+1);
wprintw(ctx->history, "Nickname set to: %s\n", nick);
}
else if(!strcmp(cmd, "/myid")) {
else if (!strcmp(cmd, "/myid")) {
char id[32*2 + 1] = {0};
int i;
for (i = 0; i < 32; i++) {
@ -187,58 +188,64 @@ void execute(ToxWindow* self, ChatContext* ctx, char* cmd)
}
wprintw(ctx->history, "Your ID: %s\n", id);
}
else if (strcmp(ctx->line, "/close") == 0) {
active_window = 0; // Go to prompt screen
int f_num = ctx->friendnum;
delwin(ctx->linewin);
del_window(self, f_num);
}
else
wprintw(ctx->history, "Invalid command.\n");
}
static void chat_onDraw(ToxWindow* self) {
static void chat_onDraw(ToxWindow *self)
{
curs_set(1);
int x, y;
ChatContext* ctx = (ChatContext*) self->x;
ChatContext *ctx = (ChatContext*) self->x;
getmaxyx(self->window, y, x);
(void) x;
if(y < 3)
return;
if (y < 3) return;
wclear(ctx->linewin);
mvwhline(ctx->linewin, 0, 0, '_', COLS);
mvwprintw(self->window, y-1, 0, "%s\n", ctx->line);
wrefresh(self->window);
}
static void chat_onInit(ToxWindow* self) {
static void chat_onInit(ToxWindow *self)
{
int x, y;
ChatContext* ctx = (ChatContext*) self->x;
ChatContext *ctx = (ChatContext*) self->x;
getmaxyx(self->window, y, x);
ctx->history = subwin(self->window, y - 4, x, 0, 0);
scrollok(ctx->history, 1);
ctx->linewin = subwin(self->window, 2, x, y - 3, 0);
print_help(ctx);
}
void print_help(ChatContext* self) {
void print_help(ChatContext *self)
{
wattron(self->history, COLOR_PAIR(2) | A_BOLD);
wprintw(self->history, "\nCommands:\n");
wprintw(self->history, "Commands:\n");
wattroff(self->history, A_BOLD);
wprintw(self->history, " /status <message> : Set your status\n");
wprintw(self->history, " /nick <nickname> : Set your nickname\n");
wprintw(self->history, " /myid : Print your ID\n");
wprintw(self->history, " /clear : Clear the screen\n");
wprintw(self->history, " /close : Close the current chat window\n");
wprintw(self->history, " /quit or /exit : Exit program\n");
wprintw(self->history, " /help : Print this message again\n\n");
wattroff(self->history, COLOR_PAIR(2));
}
ToxWindow new_chat(int friendnum) {
ToxWindow new_chat(int friendnum)
{
ToxWindow ret;
memset(&ret, 0, sizeof(ret));
ret.onKey = &chat_onKey;
@ -254,9 +261,8 @@ ToxWindow new_chat(int friendnum) {
snprintf(ret.title, sizeof(ret.title), "[%s (%d)]", nick, friendnum);
ChatContext* x = calloc(1, sizeof(ChatContext));
ChatContext *x = calloc(1, sizeof(ChatContext));
x->friendnum = friendnum;
ret.x = (void*) x;
return ret;
}

138
testing/toxic/friendlist.c
View File

@ -12,11 +12,11 @@
#include "windows.h"
extern int add_window(ToxWindow w);
extern int focus_window(int num);
extern char WINDOW_STATUS[TOXWINDOWS_MAX_NUM];
extern int add_window(ToxWindow w, int n);
extern ToxWindow new_chat(int friendnum);
#define MAX_FRIENDS_NUM 100
extern int active_window;
typedef struct {
uint8_t name[MAX_NAME_LENGTH];
@ -29,37 +29,42 @@ static friend_t friends[MAX_FRIENDS_NUM];
static int num_friends = 0;
static int num_selected = 0;
void fix_name(uint8_t* name) {
// Remove all non alphanumeric characters.
uint8_t* p = name;
uint8_t* q = name;
void fix_name(uint8_t *name)
{
/* Remove all non alphanumeric characters */
uint8_t *p = name;
uint8_t *q = name;
while(*p != 0) {
if(isprint(*p)) {
if (isprint(*p))
*q++ = *p;
}
p++;
}
*q = 0;
}
void friendlist_onMessage(ToxWindow* self, int num, uint8_t* str, uint16_t len) {
if(num >= num_friends)
void friendlist_onMessage(ToxWindow *self, int num, uint8_t *str, uint16_t len)
{
if (num >= num_friends)
return;
if(friends[num].chatwin == -1) {
friends[num].chatwin = add_window(new_chat(num));
if (friends[num].chatwin == -1) {
friends[num].chatwin = num;
int i;
/* Find first open slot to hold chat window */
for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
if (WINDOW_STATUS[i] == -1) {
WINDOW_STATUS[i] = num;
add_window(new_chat(num), i);
active_window = i;
break;
}
}
}
}
void friendlist_onNickChange(ToxWindow* self, int num, uint8_t* str, uint16_t len) {
if(len >= MAX_NAME_LENGTH || num >= num_friends)
void friendlist_onNickChange(ToxWindow *self, int num, uint8_t *str, uint16_t len)
{
if (len >= MAX_NAME_LENGTH || num >= num_friends)
return;
memcpy((char*) &friends[num].name, (char*) str, len);
@ -67,9 +72,9 @@ void friendlist_onNickChange(ToxWindow* self, int num, uint8_t* str, uint16_t le
fix_name(friends[num].name);
}
void friendlist_onStatusChange(ToxWindow* self, int num, uint8_t* str, uint16_t len) {
if(len >= MAX_USERSTATUS_LENGTH || num >= num_friends)
void friendlist_onStatusChange(ToxWindow *self, int num, uint8_t *str, uint16_t len)
{
if (len >= MAX_USERSTATUS_LENGTH || num >= num_friends)
return;
memcpy((char*) &friends[num].status, (char*) str, len);
@ -77,48 +82,59 @@ void friendlist_onStatusChange(ToxWindow* self, int num, uint8_t* str, uint16_t
fix_name(friends[num].status);
}
int friendlist_onFriendAdded(int num) {
if(num_friends == MAX_FRIENDS_NUM)
int friendlist_onFriendAdded(int num)
{
if (num_friends == MAX_FRIENDS_NUM)
return -1;
friends[num_friends].num = num;
getname(num, friends[num_friends].name);
strcpy((char*) friends[num_friends].name, "unknown");
strcpy((char*) friends[num_friends].status, "unknown");
friends[num_friends].chatwin = -1;
num_friends++;
friends[num_friends++].chatwin = -1;
return 0;
}
static void friendlist_onKey(ToxWindow* self, int key) {
if(key == KEY_UP) {
if(num_selected != 0)
num_selected--;
static void friendlist_onKey(ToxWindow *self, int key)
{
if (key == KEY_UP) {
if (--num_selected < 0)
num_selected = num_friends-1;
}
else if(key == KEY_DOWN) {
if(num_friends != 0)
else if (key == KEY_DOWN) {
if (num_friends != 0)
num_selected = (num_selected+1) % num_friends;
}
else if(key == '\n') {
if(friends[num_selected].chatwin != -1)
return;
friends[num_selected].chatwin = add_window(new_chat(num_selected));
focus_window(friends[num_selected].chatwin);
else if (key == '\n') {
/* Jump to chat window if already open */
if (friends[num_selected].chatwin != -1) {
int i;
for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
if (WINDOW_STATUS[i] == num_selected) {
active_window = i;
break;
}
}
}else {
int i;
for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
if (WINDOW_STATUS[i] == -1) {
WINDOW_STATUS[i] = num_selected;
friends[num_selected].chatwin = num_selected;
add_window(new_chat(num_selected), i);
active_window = i;
break;
}
}
}
}
}
static void friendlist_onDraw(ToxWindow* self) {
static void friendlist_onDraw(ToxWindow *self)
{
curs_set(0);
size_t i;
werase(self->window);
if(num_friends == 0) {
if (num_friends == 0) {
wprintw(self->window, "Empty. Add some friends! :-)\n");
}
else {
@ -128,12 +144,11 @@ static void friendlist_onDraw(ToxWindow* self) {
}
wprintw(self->window, "\n");
for(i=0; i<num_friends; i++) {
if(i == num_selected) wattron(self->window, COLOR_PAIR(3));
int i;
for (i = 0; i < num_friends; ++i) {
if (i == num_selected) wattron(self->window, COLOR_PAIR(3));
wprintw(self->window, " [#%d] ", friends[i].num);
if(i == num_selected) wattroff(self->window, COLOR_PAIR(3));
if (i == num_selected) wattroff(self->window, COLOR_PAIR(3));
attron(A_BOLD);
wprintw(self->window, "%s ", friends[i].name);
@ -141,18 +156,21 @@ static void friendlist_onDraw(ToxWindow* self) {
wprintw(self->window, "(%s)\n", friends[i].status);
}
wrefresh(self->window);
}
static void friendlist_onInit(ToxWindow* self) {
void disable_chatwin(int f_num)
{
friends[f_num].chatwin = -1;
}
static void friendlist_onInit(ToxWindow *self)
{
}
ToxWindow new_friendlist() {
ToxWindow ret;
memset(&ret, 0, sizeof(ret));
ret.onKey = &friendlist_onKey;
@ -161,7 +179,7 @@ ToxWindow new_friendlist() {
ret.onMessage = &friendlist_onMessage;
ret.onNickChange = &friendlist_onNickChange;
ret.onStatusChange = &friendlist_onStatusChange;
strcpy(ret.title, "[friends]");
strcpy(ret.title, "[friends]");
return ret;
}

289
testing/toxic/main.c
View File

@ -17,228 +17,238 @@ extern ToxWindow new_prompt();
extern ToxWindow new_friendlist();
extern int friendlist_onFriendAdded(int num);
extern void disable_chatwin(int f_num);
extern int add_req(uint8_t *public_key); // XXX
extern int add_req(uint8_t* public_key); // XXX
/* Holds status of chat windows */
char WINDOW_STATUS[MAX_WINDOW_SLOTS];
#define TOXWINDOWS_MAX_NUM 32
static ToxWindow windows[TOXWINDOWS_MAX_NUM];
static int w_num;
static int w_active;
static ToxWindow windows[MAX_WINDOW_SLOTS];
static ToxWindow* prompt;
// CALLBACKS START
void on_request(uint8_t* public_key, uint8_t* data, uint16_t length) {
size_t i;
int n = add_req(public_key);
int w_num;
int active_window;
/* CALLBACKS START */
void on_request(uint8_t *public_key, uint8_t *data, uint16_t length)
{
int n = add_req(public_key);
wprintw(prompt->window, "\nFriend request from:\n");
for(i=0; i<32; i++) {
int i;
for (i = 0; i < 32; ++i) {
wprintw(prompt->window, "%02x", public_key[i] & 0xff);
}
wprintw(prompt->window, "\n");
wprintw(prompt->window, "Use \"accept %d\" to accept it.\n", n);
for(i=0; i<w_num; i++) {
if(windows[i].onFriendRequest != NULL)
for (i = 0; i < MAX_WINDOW_SLOTS; ++i) {
if (windows[i].onFriendRequest != NULL)
windows[i].onFriendRequest(&windows[i], public_key, data, length);
}
}
void on_message(int friendnumber, uint8_t* string, uint16_t length) {
size_t i;
void on_message(int friendnumber, uint8_t *string, uint16_t length)
{
wprintw(prompt->window, "\n(message) %d: %s\n", friendnumber, string);
for(i=0; i<w_num; i++) {
if(windows[i].onMessage != NULL)
int i;
for (i = 0; i < MAX_WINDOW_SLOTS; ++i) {
if (windows[i].onMessage != NULL)
windows[i].onMessage(&windows[i], friendnumber, string, length);
}
}
void on_nickchange(int friendnumber, uint8_t* string, uint16_t length) {
size_t i;
void on_nickchange(int friendnumber, uint8_t *string, uint16_t length)
{
wprintw(prompt->window, "\n(nickchange) %d: %s!\n", friendnumber, string);
for(i=0; i<w_num; i++) {
if(windows[i].onNickChange != NULL)
int i;
for (i = 0; i < MAX_WINDOW_SLOTS; ++i) {
if (windows[i].onNickChange != NULL)
windows[i].onNickChange(&windows[i], friendnumber, string, length);
}
}
void on_statuschange(int friendnumber, USERSTATUS_KIND kind, uint8_t* string, uint16_t length) {
size_t i;
void on_statuschange(int friendnumber, USERSTATUS_KIND kind, uint8_t *string, uint16_t length)
{
wprintw(prompt->window, "\n(statuschange) %d: %s\n", friendnumber, string);
for(i=0; i<w_num; i++) {
if(windows[i].onStatusChange != NULL)
int i;
for (i=0; i<MAX_WINDOW_SLOTS; ++i) {
if (windows[i].onStatusChange != NULL)
windows[i].onStatusChange(&windows[i], friendnumber, string, length);
}
}
void on_friendadded(int friendnumber) {
void on_friendadded(int friendnumber)
{
friendlist_onFriendAdded(friendnumber);
}
// CALLBACKS END
/* CALLBACKS END */
static void init_term() {
// Setup terminal.
static void init_term()
{
/* Setup terminal */
initscr();
cbreak();
keypad(stdscr, 1);
noecho();
timeout(100);
if(has_colors()) {
if (has_colors()) {
start_color();
init_pair(1, COLOR_GREEN, COLOR_BLACK);
init_pair(2, COLOR_CYAN, COLOR_BLACK);
init_pair(3, COLOR_RED, COLOR_BLACK);
init_pair(4, COLOR_BLUE, COLOR_BLACK);
}
refresh();
}
static void init_tox() {
// Init core.
static void init_tox()
{
/* Init core */
initMessenger();
// Callbacks.
/* Callbacks */
m_callback_friendrequest(on_request);
m_callback_friendmessage(on_message);
m_callback_namechange(on_nickchange);
m_callback_userstatus(on_statuschange);
}
int add_window(ToxWindow w) {
if(w_num == TOXWINDOWS_MAX_NUM)
void init_window_status()
{
/* Default window values decrement from -2 */
int i;
for (i = 0; i < N_DEFAULT_WINS; ++i)
WINDOW_STATUS[i] = -(i+2);
int j;
for (j = N_DEFAULT_WINS; j < MAX_WINDOW_SLOTS; j++)
WINDOW_STATUS[j] = -1;
}
int add_window(ToxWindow w, int n)
{
if (w_num >= TOXWINDOWS_MAX_NUM)
return -1;
if(LINES < 2)
if (LINES < 2)
return -1;
w.window = newwin(LINES - 2, COLS, 0, 0);
if(w.window == NULL)
if (w.window == NULL)
return -1;
windows[w_num++] = w;
windows[n] = w;
w.onInit(&w);
return w_num - 1;
w_num++;
return n;
}
int focus_window(int num) {
if(num >= w_num || num < 0)
return -1;
w_active = num;
return 0;
/* Deletes window w and cleans up */
void del_window(ToxWindow *w, int f_num)
{
delwin(w->window);
int i;
for (i = N_DEFAULT_WINS; i < MAX_WINDOW_SLOTS; ++i) {
if (WINDOW_STATUS[i] == f_num) {
WINDOW_STATUS[i] = -1;
disable_chatwin(f_num);
break;
}
}
clear();
refresh();
}
static void init_windows() {
static void init_windows()
{
w_num = 0;
w_active = 0;
if(add_window(new_prompt()) == -1 || add_window(new_friendlist()) == -1) {
int n_prompt = 0;
int n_friendslist = 1;
if (add_window(new_prompt(), n_prompt) == -1
|| add_window(new_friendlist(), n_friendslist) == -1) {
fprintf(stderr, "add_window() failed.\n");
endwin();
exit(1);
}
prompt = &windows[0];
prompt = &windows[n_prompt];
}
static void do_tox() {
static void do_tox()
{
static bool dht_on = false;
if(!dht_on && DHT_isconnected()) {
if (!dht_on && DHT_isconnected()) {
dht_on = true;
wprintw(prompt->window, "\nDHT connected!\n");
}
else if(dht_on && !DHT_isconnected()) {
else if (dht_on && !DHT_isconnected()) {
dht_on = false;
wprintw(prompt->window, "\nDHT disconnected!\n");
}
doMessenger();
}
static void load_data(char *path) {
FILE* fd;
static void load_data(char *path)
{
FILE *fd;
size_t len;
uint8_t* buf;
uint8_t *buf;
if((fd = fopen(path, "r")) != NULL) {
if ((fd = fopen(path, "r")) != NULL) {
fseek(fd, 0, SEEK_END);
len = ftell(fd);
fseek(fd, 0, SEEK_SET);
buf = malloc(len);
if(buf == NULL) {
if (buf == NULL) {
fprintf(stderr, "malloc() failed.\n");
fclose(fd);
endwin();
exit(1);
}
if(fread(buf, len, 1, fd) != 1){
if (fread(buf, len, 1, fd) != 1){
fprintf(stderr, "fread() failed.\n");
free(buf);
fclose(fd);
endwin();
exit(1);
}
Messenger_load(buf, len);
}
else {
len = Messenger_size();
buf = malloc(len);
if(buf == NULL) {
if (buf == NULL) {
fprintf(stderr, "malloc() failed.\n");
endwin();
exit(1);
}
Messenger_save(buf);
fd = fopen(path, "w");
if(fd == NULL) {
if (fd == NULL) {
fprintf(stderr, "fopen() failed.\n");
free(buf);
endwin();
exit(1);
}
if(fwrite(buf, len, 1, fd) != 1){
if (fwrite(buf, len, 1, fd) != 1){
fprintf(stderr, "fwrite() failed.\n");
free(buf);
fclose(fd);
endwin();
exit(1);
}
}
free(buf);
fclose(fd);
}
static void draw_bar() {
static void draw_bar()
{
static int odd = 0;
size_t i;
attron(COLOR_PAIR(4));
mvhline(LINES - 2, 0, '_', COLS);
@ -250,95 +260,124 @@ static void draw_bar() {
printw(" TOXIC 1.0 |");
attroff(COLOR_PAIR(4) | A_BOLD);
for(i=0; i<w_num; i++) {
if(i == w_active) {
int i;
for (i = 0; i < (MAX_WINDOW_SLOTS); ++i) {
if (WINDOW_STATUS[i] != -1) {
if (i == active_window)
attron(A_BOLD);
}
odd = (odd+1) % 10;
if(windows[i].blink && (odd < 5)) {
if (windows[i].blink && (odd < 5)) {
attron(COLOR_PAIR(3));
}
printw(" %s", windows[i].title);
if(windows[i].blink && (odd < 5)) {
if (windows[i].blink && (odd < 5)) {
attron(COLOR_PAIR(3));
}
if(i == w_active) {
if (i == active_window) {
attroff(A_BOLD);
}
}
}
refresh();
}
void prepare_window(WINDOW* w) {
void prepare_window(WINDOW *w)
{
mvwin(w, 0, 0);
wresize(w, LINES-2, COLS);
}
int main(int argc, char* argv[]) {
/* Shows next window when tab or back-tab is pressed */
void set_active_window(int ch)
{
int f_inf = 0;
int max = MAX_WINDOW_SLOTS-1;
if (ch == '\t') {
int i = (active_window + 1) % max;
while (true) {
if (WINDOW_STATUS[i] != -1) {
active_window = i;
return;
}
i = (i + 1) % max;
if (f_inf++ > max) { // infinite loop check
endwin();
clear();
exit(2);
}
}
}else {
int i = active_window - 1;
if (i < 0) i = max;
while (true) {
if (WINDOW_STATUS[i] != -1) {
active_window = i;
return;
}
if (--i < 0) i = max;
if (f_inf++ > max) {
endwin();
clear();
exit(2);
}
}
}
}
int main(int argc, char *argv[])
{
int ch;
int i = 0;
int f_flag = 0;
char *filename = "data";
ToxWindow* a;
for(i = 0; i < argc; i++) {
if (argv[i] == NULL){
int i = 0;
for (i = 0; i < argc; ++i) {
if (argv[i] == NULL)
break;
} else if(argv[i][0] == '-') {
if(argv[i][1] == 'f') {
if(argv[i + 1] != NULL)
else if (argv[i][0] == '-') {
if (argv[i][1] == 'f') {
if (argv[i + 1] != NULL)
filename = argv[i + 1];
else {
else
f_flag = -1;
}
}
}
}
init_term();
init_tox();
load_data(filename);
init_windows();
init_window_status();
if(f_flag == -1) {
if (f_flag == -1) {
attron(COLOR_PAIR(3) | A_BOLD);
wprintw(prompt->window, "You passed '-f' without giving an argument!\n"
"defaulting to 'data' for a keyfile...\n");
attroff(COLOR_PAIR(3) | A_BOLD);
}
while(true) {
// Update tox.
/* Update tox */
do_tox();
// Draw.
a = &windows[w_active];
/* Draw */
a = &windows[active_window];
prepare_window(a->window);
a->blink = false;
draw_bar();
a->onDraw(a);
// Handle input.
/* Handle input */
ch = getch();
if(ch == '\t') {
w_active = (w_active + 1) % w_num;
}
else if(ch == KEY_BTAB) {
w_active = (w_active + w_num - 1) % w_num;
}
else if(ch != ERR) {
if (ch == '\t' || ch == KEY_BTAB)
set_active_window(ch);
else if (ch != ERR) {
a->onKey(a, ch);
}
}
return 0;
}

214
testing/toxic/prompt.c
View File

@ -1,6 +1,6 @@
/*
* Toxic -- Tox Curses Client
*/
* Toxic -- Tox Curses Client
*/
#include <stdlib.h>
#include <string.h>
@ -16,73 +16,78 @@ uint8_t pending_requests[256][CLIENT_ID_SIZE]; // XXX
uint8_t num_requests=0; // XXX
extern void on_friendadded(int friendnumber);
static void print_usage(ToxWindow* self);
static void print_usage(ToxWindow *self);
static char prompt_buf[256] = {0};
static int prompt_buf_pos = 0;
// XXX:
int add_req(uint8_t* public_key) {
int add_req(uint8_t *public_key)
{
memcpy(pending_requests[num_requests], public_key, CLIENT_ID_SIZE);
++num_requests;
return num_requests-1;
}
// XXX: FIX
unsigned char * hex_string_to_bin(char hex_string[])
unsigned char *hex_string_to_bin(char hex_string[])
{
size_t len = strlen(hex_string);
unsigned char *val = malloc(len);
char *pos = hex_string;
int i;
for(i = 0; i < len; ++i, pos+=2)
for (i = 0; i < len; ++i, pos+=2)
sscanf(pos,"%2hhx",&val[i]);
return val;
}
static char prompt_buf[256] = {0};
static int prompt_buf_pos=0;
static void execute(ToxWindow *self, char *u_cmd)
{
int newlines = 0;
char cmd[256] = {0};
int i;
for (i = 0; i < strlen(prompt_buf); ++i) {
if (u_cmd[i] == '\n')
++newlines;
else
cmd[i - newlines] = u_cmd[i];
}
static void execute(ToxWindow* self, char* cmd) {
if(!strcmp(cmd, "quit") || !strcmp(cmd, "exit") || !strcmp(cmd, "q")) {
if (!strcmp(cmd, "quit") || !strcmp(cmd, "exit") || !strcmp(cmd, "q")) {
endwin();
exit(0);
}
else if(!strncmp(cmd, "connect ", strlen("connect "))) {
char* ip;
char* port;
char* key;
IP_Port dht;
ip = strchr(cmd, ' ');
if(ip == NULL) {
else if (!strncmp(cmd, "connect ", strlen("connect "))) {
IP_Port dht;
char *ip = strchr(cmd, ' ');
if (ip == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
ip++;
port = strchr(ip, ' ');
if(port == NULL) {
char *port = strchr(ip, ' ');
if (port == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
port[0] = 0;
port++;
key = strchr(port, ' ');
if(key == NULL) {
char *key = strchr(port, ' ');
if (key == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
key[0] = 0;
key++;
if(atoi(port) == 0) {
if (atoi(port) == 0) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
dht.port = htons(atoi(port));
uint32_t resolved_address = resolve_addr(ip);
if (resolved_address == 0) {
return;
@ -93,49 +98,39 @@ static void execute(ToxWindow* self, char* cmd) {
DHT_bootstrap(dht, binary_string);
free(binary_string);
}
else if(!strncmp(cmd, "add ", strlen("add "))) {
else if (!strncmp(cmd, "add ", strlen("add "))) {
uint8_t id_bin[32];
size_t i;
char xx[3];
uint32_t x;
char* id;
char* msg;
int num;
id = strchr(cmd, ' ');
if(id == NULL) {
char *id = strchr(cmd, ' ');
if (id == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
id++;
msg = strchr(id, ' ');
if(msg != NULL) {
char *msg = strchr(id, ' ');
if (msg != NULL) {
msg[0] = 0;
msg++;
}
else msg = "";
if(strlen(id) != 2*32) {
if (strlen(id) != 2*32) {
wprintw(self->window, "Invalid ID length.\n");
return;
}
for(i=0; i<32; i++) {
int i;
for (i = 0; i < 32; ++i) {
xx[0] = id[2*i];
xx[1] = id[2*i+1];
xx[2] = '\0';
if(sscanf(xx, "%02x", &x) != 1) {
if (sscanf(xx, "%02x", &x) != 1) {
wprintw(self->window, "Invalid ID.\n");
return;
}
id_bin[i] = x;
}
num = m_addfriend(id_bin, (uint8_t*) msg, strlen(msg)+1);
int num = m_addfriend(id_bin, (uint8_t*) msg, strlen(msg)+1);
switch (num) {
case -1:
wprintw(self->window, "Message is too long.\n");
@ -158,154 +153,153 @@ static void execute(ToxWindow* self, char* cmd) {
break;
}
}
else if(!strcmp(cmd, "clear")) {
else if (!strcmp(cmd, "clear")) {
wclear(self->window);
}
else if(!strcmp(cmd, "help")) {
else if (!strcmp(cmd, "help")) {
wclear(self->window);
print_usage(self);
}
else if(!strncmp(cmd, "status ", strlen("status "))) {
char* msg;
msg = strchr(cmd, ' ');
if(msg == NULL) {
else if (!strncmp(cmd, "status ", strlen("status "))) {
char *msg = strchr(cmd, ' ');
if (msg == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
msg++;
m_set_userstatus(USERSTATUS_KIND_RETAIN, (uint8_t*) msg, strlen(msg)+1);
wprintw(self->window, "Status set to: %s\n", msg);
}
else if(!strncmp(cmd, "nick ", strlen("nick "))) {
char* nick;
nick = strchr(cmd, ' ');
if(nick == NULL) {
else if (!strncmp(cmd, "nick ", strlen("nick "))) {
char *nick = strchr(cmd, ' ');
if (nick == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
nick++;
setname((uint8_t*) nick, strlen(nick)+1);
wprintw(self->window, "Nickname set to: %s\n", nick);
}
else if(!strcmp(cmd, "myid")) {
else if (!strcmp(cmd, "myid")) {
char id[32*2 + 1] = {0};
size_t i;
for(i=0; i<32; i++) {
for (i = 0; i < 32; ++i) {
char xx[3];
snprintf(xx, sizeof(xx), "%02x", self_public_key[i] & 0xff);
strcat(id, xx);
}
wprintw(self->window, "Your ID: %s\n", id);
}
else if(!strncmp(cmd, "accept ", strlen("accept "))) {
char* id;
int num;
id = strchr(cmd, ' ');
if(id == NULL) {
else if (!strncmp(cmd, "accept ", strlen("accept "))) {
char *id = strchr(cmd, ' ');
if (id == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
id++;
num = atoi(id);
if(num >= num_requests) {
int num = atoi(id);
if (num >= num_requests) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
num = m_addfriend_norequest(pending_requests[num]);
if(num == -1) {
if (num == -1)
wprintw(self->window, "Failed to add friend.\n");
}
else {
wprintw(self->window, "Friend accepted as: %d.\n", num);
on_friendadded(num);
}
}
else if(!strncmp(cmd, "msg ", strlen("msg "))) {
char* id;
char* msg;
id = strchr(cmd, ' ');
if(id == NULL) {
else if (!strncmp(cmd, "msg ", strlen("msg "))) {
char *id = strchr(cmd, ' ');
if (id == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
id++;
msg = strchr(id, ' ');
if(msg == NULL) {
char *msg = strchr(++id, ' ');
if (msg == NULL) {
wprintw(self->window, "Invalid syntax.\n");
return;
}
msg[0] = 0;
msg++;
if(m_sendmessage(atoi(id), (uint8_t*) msg, strlen(msg)+1) < 0) {
if (m_sendmessage(atoi(id), (uint8_t*) msg, strlen(msg)+1) < 0)
wprintw(self->window, "Error occurred while sending message.\n");
}
else {
else
wprintw(self->window, "Message successfully sent.\n");
}
}
else {
else
wprintw(self->window, "Invalid command.\n");
}
}
static void prompt_onKey(ToxWindow* self, int key) {
// PRINTABLE characters: Add to line.
if(isprint(key)) {
if(prompt_buf_pos == (sizeof(prompt_buf) - 1)) {
return;
static void prompt_onKey(ToxWindow *self, int key)
{
/* Add printable characters to line */
if (isprint(key)) {
if (prompt_buf_pos == (sizeof(prompt_buf) - 1)) {
wprintw(self->window, "\nToo Long.\n");
prompt_buf_pos = 0;
prompt_buf[0] = 0;
}
else if (!(prompt_buf_pos == 0) && (prompt_buf_pos < COLS)
&& (prompt_buf_pos % (COLS - 3) == 0)) {
prompt_buf[prompt_buf_pos++] = '\n';
}
else if (!(prompt_buf_pos == 0) && (prompt_buf_pos > COLS)
&& ((prompt_buf_pos - (COLS - 3)) % (COLS) == 0)) {
prompt_buf[prompt_buf_pos++] = '\n';
}
prompt_buf[prompt_buf_pos++] = key;
prompt_buf[prompt_buf_pos] = 0;
}
// RETURN key: execute command.
else if(key == '\n') {
/* RETURN key: execute command */
else if (key == '\n') {
wprintw(self->window, "\n");
execute(self, prompt_buf);
prompt_buf_pos = 0;
prompt_buf[0] = 0;
}
// BACKSPACE key: Remove one character from line.
else if(key == 0x107 || key == 0x8 || key == 0x7f) {
if(prompt_buf_pos != 0) {
/* BACKSPACE key: Remove one character from line */
else if (key == 0x107 || key == 0x8 || key == 0x7f) {
if (prompt_buf_pos != 0) {
prompt_buf[--prompt_buf_pos] = 0;
}
}
}
static void prompt_onDraw(ToxWindow* self) {
static void prompt_onDraw(ToxWindow *self)
{
curs_set(1);
int x, y;
getyx(self->window, y, x);
(void) x;
int i;
for (i = 0; i < (strlen(prompt_buf)); ++i) {
if ((prompt_buf[i] == '\n') && (y != 0))
--y;
}
wattron(self->window, COLOR_PAIR(1));
mvwprintw(self->window, y, 0, "# ");
wattroff(self->window, COLOR_PAIR(1));
mvwprintw(self->window, y, 2, "%s", prompt_buf);
wclrtoeol(self->window);
wrefresh(self->window);
}
static void print_usage(ToxWindow* self) {
static void print_usage(ToxWindow *self)
{
wattron(self->window, COLOR_PAIR(2) | A_BOLD);
wprintw(self->window, "Commands:\n");
wattroff(self->window, A_BOLD);
@ -327,22 +321,20 @@ static void print_usage(ToxWindow* self) {
wattroff(self->window, COLOR_PAIR(2));
}
static void prompt_onInit(ToxWindow* self) {
static void prompt_onInit(ToxWindow *self)
{
scrollok(self->window, 1);
print_usage(self);
wclrtoeol(self->window);
}
ToxWindow new_prompt() {
ToxWindow new_prompt()
{
ToxWindow ret;
memset(&ret, 0, sizeof(ret));
ret.onKey = &prompt_onKey;
ret.onDraw = &prompt_onDraw;
ret.onInit = &prompt_onInit;
strcpy(ret.title, "[prompt]");
return ret;
}

8
testing/toxic/windows.h
View File

@ -3,6 +3,14 @@
*/
#include <stdbool.h>
#define TOXWINDOWS_MAX_NUM 32
#define MAX_FRIENDS_NUM 100
/* number of permanent default windows */
#define N_DEFAULT_WINS 2
/* maximum window slots for WINDOW_STATUS array */
#define MAX_WINDOW_SLOTS N_DEFAULT_WINS+MAX_FRIENDS_NUM
typedef struct ToxWindow_ ToxWindow;