add toxme.se to dns3 server list

Add libresolv

.travis.yml

@@ -4,23 +4,52 @@ compiler:
   - clang
 
 before_script:
-# installing libsodium, needed for Core
-  - git clone git://github.com/jedisct1/libsodium.git
+  #installing libsodium, needed for Core
+  - git clone git://github.com/jedisct1/libsodium.git > /dev/null
   - cd libsodium
-  - git checkout tags/0.4.2
-  - ./autogen.sh
-  - ./configure && make -j3
-  - sudo make install 
+  - git checkout tags/0.4.2 > /dev/null
+  - ./autogen.sh > /dev/null
+  - ./configure > /dev/null
+  - make check -j3 > /dev/null
+  - sudo make install >/dev/null
   - cd ..
+  #installing yasm, needed for compiling vpx
+  - sudo apt-get install yasm > /dev/null
+  #installing libconfig, needed for DHT_bootstrap_daemon
+  - wget http://www.hyperrealm.com/libconfig/libconfig-1.4.9.tar.gz > /dev/null
+  - tar -xvzf libconfig-1.4.9.tar.gz > /dev/null
+  - cd libconfig-1.4.9
+  - ./configure > /dev/null
+  - make -j3 > /dev/null
+  - sudo make install > /dev/null
+  - cd ..
+  #installing libopus, needed for audio encoding/decoding
+  - wget http://downloads.xiph.org/releases/opus/opus-1.0.3.tar.gz > /dev/null
+  - tar xzf opus-1.0.3.tar.gz > /dev/null
+  - cd opus-1.0.3
+  - ./configure > /dev/null
+  - make -j3 > /dev/null
+  - sudo make install > /dev/null
+  - cd ..
+  #installing vpx
+  - git clone http://git.chromium.org/webm/libvpx.git > /dev/null
+  - cd libvpx
+  - ./configure --enable-shared > /dev/null
+  - make -j3 >/dev/null
+  - sudo make install > /dev/null
+  - cd ..
+  #creating libraries links and updating cache
+  - sudo ldconfig > /dev/null
 # creating librarys' links and updating cache
   - sudo ldconfig
   - git clone https://github.com/irungentoo/ProjectTox-Core.git toxcore
   - cd toxcore
   - autoreconf -i
-  - ./configure --disable-tests --disable-ntox --disable-dht-bootstrap-daemon
+  - ./configure --disable-tests --disable-ntox --disable-daemon --enable-av
   - make -j2
   - sudo make install
   - cd ..
+  - sudo apt-get install libopenal-dev -yq
 script:
   - autoreconf -i
   - ./configure

README.md

@@ -1,20 +1,25 @@
-## Toxic - console client for [Tox](http://tox.im)
+# Toxic
 
-The client formerly resided in the [Tox core repository](https://github.com/irungentoo/ProjectTox-Core) and is now available as a standalone program. It looks like [this](http://wiki.tox.im/images/b/b6/Ncursesclient1.png).
+Toxic is an ncurses based instant messaging client for [Tox](http://tox.im) which formerly resided in the [Tox core repository](https://github.com/irungentoo/ProjectTox-Core) and is now available as a standalone program. It looks like [this](http://i.imgur.com/hL7WhVl.png).
+## Installation
+* Generate the configure script by running the ```autoreconf -i``` command.
 
-To compile, first generate the configure script by running the ```autoreconf -i``` command.
+* Execute the configure script with ```./configure``` (you may need to pass it the location of your dependency libraries, i.e.):
+```./configure --prefix=/where/to/install --with-libtoxcore-headers=/path/to/ProjectTox-Core/toxcore --with-libtoxcore-libs=/path/to/ProjectTox-Core/build/.libs --with-libsodium-headers=/path/to/libsodium/include/ --with-libsodium-libs=/path/to/sodiumtest/lib/ ```
 
-Then execute the configure script with ./configure (you may need to pass it the location of your dependency libraries, i.e.):
-```
-./configure --prefix=/where/to/install --with-libtoxcore-headers=/path/to/ProjectTox-Core/core --with-libtoxcore-libs=/path/to/ProjectTox-Core/build/core --with-libsodium-headers=/path/to/libsodium/include/ --with-libsodium-libs=/path/to/sodiumtest/lib/
+* Audio calling support requires openal installed
+* Compile with --disable-av to build without audio call support
+* Compile and install the program with ```make && sudo make install```
 
-```
-*Note:* If your default prefix is /usr/local and you happen to get an error that says "error while loading shared libraries: libtoxcore.so.0: cannot open shared object file: No such file or directory", then you can try running ```sudo ldconfig```. If that doesn't fix it, run:
+#### Notes
+If your default prefix is /usr/local and you get the error: "error while loading shared libraries: libtoxcore.so.0: cannot open shared object file: No such file or directory", then you can try running ```sudo ldconfig```. If that doesn't fix it, run:
 ```
 echo '/usr/local/lib/' | sudo tee -a /etc/ld.so.conf.d/locallib.conf
 sudo ldconfig
 ```
-If you dont already have them, you might want to install the ncurses libraries, on Debian:
+If you dont already have them, you may need to install the ncurses libraries. For Debian based systems:
 ```
 sudo apt-get install libncurses5-dev libncursesw5-dev
 ```
+## Settings
+After running Toxic for the first time an empty file called toxic.conf should reside in your home configuration directory (~/.config/tox for Linux users). For an example on how to use this config file to save settings such as auto-logging and time format see: toxic/misc/toxic.conf

build/Makefile.am

@@ -3,7 +3,8 @@
 bin_PROGRAMS = toxic
 
 
-toxic_SOURCES = $(top_srcdir)/src/main.c \
+toxic_SOURCES = $(top_srcdir)/src/toxic.c \
+                $(top_srcdir)/src/toxic.h \
                 $(top_srcdir)/src/chat.h \
                 $(top_srcdir)/src/chat.c \
                 $(top_srcdir)/src/configdir.h \
@@ -12,8 +13,8 @@ toxic_SOURCES = $(top_srcdir)/src/main.c \
                 $(top_srcdir)/src/prompt.c \
                 $(top_srcdir)/src/friendlist.h \
                 $(top_srcdir)/src/friendlist.c \
-                $(top_srcdir)/src/toxic_windows.h \
                 $(top_srcdir)/src/windows.c \
+                $(top_srcdir)/src/windows.h \
                 $(top_srcdir)/src/groupchat.c \
                 $(top_srcdir)/src/groupchat.h \
                 $(top_srcdir)/src/global_commands.c \
@@ -25,12 +26,23 @@ toxic_SOURCES = $(top_srcdir)/src/main.c \
                 $(top_srcdir)/src/misc_tools.c \
                 $(top_srcdir)/src/misc_tools.h \
                 $(top_srcdir)/src/toxic_strings.c \
-                $(top_srcdir)/src/toxic_strings.h
+                $(top_srcdir)/src/toxic_strings.h \
+                $(top_srcdir)/src/log.c \
+                $(top_srcdir)/src/log.h \
+                $(top_srcdir)/src/file_senders.c \
+                $(top_srcdir)/src/file_senders.h \
+                $(top_srcdir)/src/line_info.c \
+                $(top_srcdir)/src/line_info.h \
+                $(top_srcdir)/src/settings.c \
+                $(top_srcdir)/src/settings.h \
+                $(top_srcdir)/src/dns.c \
+                $(top_srcdir)/src/dns.h
 
 toxic_CFLAGS =  -I$(top_srcdir) \
 				  $(NCURSES_CFLAGS) \
 				  $(LIBSODIUM_CFLAGS) \
-				$(LIBTOXCORE_CFLAGS)
+				  $(LIBTOXCORE_CFLAGS) \
+				  $(PTHREAD_CFLAGS)
 
 toxic_CPPFLAGS = '-DTOXICVER="$(TOXIC_VERSION)"'
 
@@ -39,5 +51,19 @@ toxic_LDADD =	$(LIBTOXCORE_LDFLAGS) \
 				$(NCURSES_LIBS) \
 				$(LIBTOXCORE_LIBS) \
 				$(LIBSODIUM_LIBS) \
-                $(WINSOCK2_LIBS)
+                $(WINSOCK2_LIBS) \
+                $(PTHREAD_LIBS)
 
+
+# For audio support
+if BUILD_AV
+
+toxic_SOURCES += $(top_srcdir)/src/audio_call.c \
+                 $(top_srcdir)/src/audio_call.h
+
+toxic_CFLAGS += $(LIBTOXAV_CFLAGS) \
+		$(OPENAL_CFLAGS)
+		
+toxic_LDADD += $(LIBTOXAV_LIBS) \
+	       $(OPENAL_LIBS) 
+endif

configure.ac

@@ -2,9 +2,9 @@
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ([2.65])
-AC_INIT([toxic], [0.2.5], [https://tox.im/])
+AC_INIT([toxic], [0.4.1], [https://tox.im/])
 AC_CONFIG_AUX_DIR(configure_aux)
-AC_CONFIG_SRCDIR([src/main.c])
+AC_CONFIG_SRCDIR([src/toxic.c])
 AC_CONFIG_HEADERS([config.h])
 AM_INIT_AUTOMAKE([1.10 -Wall])
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
@@ -37,7 +37,7 @@ if test -n "$DEPSEARCH"; then
     CFLAGS="$CFLAGS -I$DEPSEARCH/include"
     CPPFLAGS="$CPPFLAGS -I$DEPSEARCH/include"
     LDFLAGS="$LDFLAGS -L$DEPSEARCH/lib"
-    export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$DEPSEARCH/lib/pkgconfig
+    export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$DEPSEARCH/lib/pkgconfig:/usr/local/lib/pkgconfig
 fi
 
 AC_ARG_WITH(libtoxcore-headers,
@@ -77,11 +77,15 @@ AC_ARG_WITH(libsodium-libs,
 )
 
 WIN32=no
+MACH=no
 AC_CANONICAL_HOST
 case $host_os in
     *mingw*)
         WIN32="yes"
     ;;
+    darwin*)
+        MACH=yes
+    ;;
     *freebsd*)
         LDFLAGS="$LDFLAGS -L/usr/local/lib"
         CFLAGS="$CFLAGS -I/usr/local/include"
@@ -113,6 +117,8 @@ AC_CHECK_FUNCS(
     [],
     [ AC_MSG_ERROR([required library function is missing on your system])])
 
+AX_PTHREAD( [], [ AC_MSG_ERROR([pthreads not found on your system]) ])
+
 # pkg-config based tests
 PKG_PROG_PKG_CONFIG
 
@@ -381,6 +387,100 @@ if test "x$LIBTOXCORE_FOUND" = "xno"; then
     AC_SUBST(LIBTOXCORE_LDFLAGS)
 fi
 
+AC_CHECK_HEADER([resolv.h], [],
+                [
+                    AC_MSG_ERROR([resolv.h header was not found on your system])
+                ])
+
+AC_CHECK_LIB(resolv, __res_init, [],
+             [
+                AC_MSG_ERROR([libresolv library was not found on your system])
+             ])
+
+####
+#### A/V Stuff
+
+AV_SEARCH_DIR=
+BUILD_AV="yes"
+
+AC_ARG_WITH(libtoxav-prefix,
+    AC_HELP_STRING([--with-libtoxav-prefix=DIR],
+                   [search for libtoxav in DIR, i.e. look for libraries in
+                    DIR/lib and for headers in DIR/include]),
+    [
+        AV_SEARCH_DIR="$withval"
+    ]
+)
+
+if test -n "$AV_SEARCH_DIR"; then
+    CFLAGS="$CFLAGS -I$AV_SEARCH_DIR/include"
+    CPPFLAGS="$CPPFLAGS -I$AV_SEARCH_DIR/include"
+    LDFLAGS="$LDFLAGS -L$AV_SEARCH_DIR/lib"
+    export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$AV_SEARCH_DIR/lib/pkgconfig
+fi
+
+# Check if specified enable
+AC_ARG_ENABLE([av],
+    [AC_HELP_STRING([--disable-av], [build AV support libraries (default: auto)]) ],
+    [
+        if test "x$enableval" = "xno"; then
+            BUILD_AV="no"
+        elif test "x$enableval" = "xyes"; then
+            BUILD_AV="yes"
+        fi
+    ]
+)
+
+# Check for A/V library
+
+if test "x$BUILD_AV" = "xyes"; then
+    PKG_CHECK_MODULES([OPENAL], [openal],
+    [],
+    [
+        if test "x$MACH" = "xyes"; then
+            CFLAGS="$CFLAGS -framework OpenAL"
+            AC_CHECK_HEADER([OpenAL/al.h],
+                [
+                    OPENAL_CFLAGS="-framework OpenAL"
+                    OPENAL_LIBS="-framework OpenAL"
+                    AC_SUBST(OPENAL_CFLAGS)
+                    AC_SUBST(OPENAL_LIBS)
+                ],
+                [
+                    AC_MSG_NOTICE([No openal framework; disabling A/V support])
+                    BUILD_AV="no"
+                ]
+            )
+            CFLAGS="$CFLAGS_SAVE"
+        else
+            AC_MSG_NOTICE([No openal library; disabling A/V support])
+            BUILD_AV="no"
+        fi
+    ])
+fi
+
+if test "x$BUILD_AV" = "xyes"; then
+    PKG_CHECK_MODULES([LIBTOXAV], [libtoxav],
+    [
+        AC_CHECK_HEADER([tox/toxav.h],
+        [
+            # Place define for audio support
+            AC_DEFINE([_SUPPORT_AUDIO], [], [Is audio supported])
+            AC_MSG_NOTICE([Building with audio support])
+        ],
+        [
+            AC_MSG_NOTICE([No A/V headers; disabling A/V support])
+            BUILD_AV="no"
+        ],)
+    ],
+    [
+        AC_MSG_NOTICE([No A/V library; disabling A/V support])
+        BUILD_AV="no"
+    ])
+fi
+
+AM_CONDITIONAL(BUILD_AV, test "x$BUILD_AV" = "xyes")
+
 TOXIC_VERSION="$PACKAGE_VERSION"
 AC_PATH_PROG([GIT], [git], [no])
 if test "x$GIT" != "xno"; then

fun/unixtime.patch

@@ -0,0 +1,52 @@
+--- /src/misc_tools.c
++++ /src/misc_tools.c
+@@ -54,24 +54,11 @@
+     return val;
+ }
+ 
+-/* Get the current local time */
+-struct tm *get_time(void)
+-{
+-    struct tm *timeinfo;
+-    time_t now;
+-    time(&now);
+-    timeinfo = localtime(&now);
+-    return timeinfo;
+-}
+-
+ /* Prints the time to given window */
+ void print_time(WINDOW *window)
+ {
+-    uint8_t s[MAX_STR_SIZE];
+-    strftime(s, MAX_STR_SIZE, "[%H:%M:%S] ", get_time());
+-
+     wattron(window, COLOR_PAIR(BLUE));
+-    wprintw(window, "%s", s);
++    wprintw(window, "[%d] ", (int)time(NULL));
+     wattroff(window,COLOR_PAIR(BLUE));
+ }
+ 
+--- /src/log.c
++++ /src/log.c
+@@ -51,9 +51,7 @@
+         sprintf(&ident[2], "%02X", key[2] & 0xff);
+         ident[KEY_IDENT_DIGITS*2+1] = '\0';
+     } else {
+-        uint8_t s[MAX_STR_SIZE];
+-        strftime(s, MAX_STR_SIZE, "%Y-%m-%d[%H:%M:%S]", get_time());
+-        snprintf(ident, sizeof(ident), "%s", s);
++        snprintf(ident, sizeof(ident), "[%d]", (int)time(NULL));
+         path_len += strlen(ident) + 1;
+     }
+ 
+@@ -95,9 +93,7 @@
+     else
+         snprintf(name_frmt, sizeof(name_frmt), "%s:", name);
+ 
+-    uint8_t s[MAX_STR_SIZE];
+-    strftime(s, MAX_STR_SIZE, "%Y/%m/%d [%H:%M:%S]", get_time());
+-    fprintf(log->file,"%s %s %s\n", s, name_frmt, msg);
++    fprintf(log->file,"[%d]\n", (int)time(NULL), name_frmt, msg);
+ 
+     uint64_t curtime = (uint64_t) time(NULL);
+ 

m4/ax_pthread.m4

@@ -0,0 +1,317 @@
+# ===========================================================================
+#        http://www.gnu.org/software/autoconf-archive/ax_pthread.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+#
+# DESCRIPTION
+#
+#   This macro figures out how to build C programs using POSIX threads. It
+#   sets the PTHREAD_LIBS output variable to the threads library and linker
+#   flags, and the PTHREAD_CFLAGS output variable to any special C compiler
+#   flags that are needed. (The user can also force certain compiler
+#   flags/libs to be tested by setting these environment variables.)
+#
+#   Also sets PTHREAD_CC to any special C compiler that is needed for
+#   multi-threaded programs (defaults to the value of CC otherwise). (This
+#   is necessary on AIX to use the special cc_r compiler alias.)
+#
+#   NOTE: You are assumed to not only compile your program with these flags,
+#   but also link it with them as well. e.g. you should link with
+#   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#
+#   If you are only building threads programs, you may wish to use these
+#   variables in your default LIBS, CFLAGS, and CC:
+#
+#     LIBS="$PTHREAD_LIBS $LIBS"
+#     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+#     CC="$PTHREAD_CC"
+#
+#   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
+#   has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name
+#   (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+#
+#   Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
+#   PTHREAD_PRIO_INHERIT symbol is defined when compiling with
+#   PTHREAD_CFLAGS.
+#
+#   ACTION-IF-FOUND is a list of shell commands to run if a threads library
+#   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
+#   is not found. If ACTION-IF-FOUND is not specified, the default action
+#   will define HAVE_PTHREAD.
+#
+#   Please let the authors know if this macro fails on any platform, or if
+#   you have any other suggestions or comments. This macro was based on work
+#   by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
+#   from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
+#   Alejandro Forero Cuervo to the autoconf macro repository. We are also
+#   grateful for the helpful feedback of numerous users.
+#
+#   Updated for Autoconf 2.68 by Daniel Richard G.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+#   Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 20
+
+AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
+AC_DEFUN([AX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_LANG_PUSH([C])
+ax_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on True64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
+        AC_TRY_LINK_FUNC(pthread_join, ax_pthread_ok=yes)
+        AC_MSG_RESULT($ax_pthread_ok)
+        if test x"$ax_pthread_ok" = xno; then
+                PTHREAD_LIBS=""
+                PTHREAD_CFLAGS=""
+        fi
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try.  Items starting with a "-" are
+# C compiler flags, and other items are library names, except for "none"
+# which indicates that we try without any flags at all, and "pthread-config"
+# which is a program returning the flags for the Pth emulation library.
+
+ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important.  Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+#       other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
+# -pthreads: Solaris/gcc
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads too;
+#      also defines -D_REENTRANT)
+#      ... -mt is also the pthreads flag for HP/aCC
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case ${host_os} in
+        solaris*)
+
+        # On Solaris (at least, for some versions), libc contains stubbed
+        # (non-functional) versions of the pthreads routines, so link-based
+        # tests will erroneously succeed.  (We need to link with -pthreads/-mt/
+        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
+        # a function called by this macro, so we could check for that, but
+        # who knows whether they'll stub that too in a future libc.)  So,
+        # we'll just look for -pthreads and -lpthread first:
+
+        ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags"
+        ;;
+
+        darwin*)
+        ax_pthread_flags="-pthread $ax_pthread_flags"
+        ;;
+esac
+
+if test x"$ax_pthread_ok" = xno; then
+for flag in $ax_pthread_flags; do
+
+        case $flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $flag])
+                PTHREAD_CFLAGS="$flag"
+                ;;
+
+                pthread-config)
+                AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no)
+                if test x"$ax_pthread_config" = xno; then continue; fi
+                PTHREAD_CFLAGS="`pthread-config --cflags`"
+                PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+                ;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$flag])
+                PTHREAD_LIBS="-l$flag"
+                ;;
+        esac
+
+        save_LIBS="$LIBS"
+        save_CFLAGS="$CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Check for various functions.  We must include pthread.h,
+        # since some functions may be macros.  (On the Sequent, we
+        # need a special flag -Kthread to make this header compile.)
+        # We check for pthread_join because it is in -lpthread on IRIX
+        # while pthread_create is in libc.  We check for pthread_attr_init
+        # due to DEC craziness with -lpthreads.  We check for
+        # pthread_cleanup_push because it is one of the few pthread
+        # functions on Solaris that doesn't have a non-functional libc stub.
+        # We try pthread_create on general principles.
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>
+                        static void routine(void *a) { a = 0; }
+                        static void *start_routine(void *a) { return a; }],
+                       [pthread_t th; pthread_attr_t attr;
+                        pthread_create(&th, 0, start_routine, 0);
+                        pthread_join(th, 0);
+                        pthread_attr_init(&attr);
+                        pthread_cleanup_push(routine, 0);
+                        pthread_cleanup_pop(0) /* ; */])],
+                [ax_pthread_ok=yes],
+                [])
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        AC_MSG_RESULT($ax_pthread_ok)
+        if test "x$ax_pthread_ok" = xyes; then
+                break;
+        fi
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+# Various other checks:
+if test "x$ax_pthread_ok" = xyes; then
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+        AC_MSG_CHECKING([for joinable pthread attribute])
+        attr_name=unknown
+        for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+            AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
+                           [int attr = $attr; return attr /* ; */])],
+                [attr_name=$attr; break],
+                [])
+        done
+        AC_MSG_RESULT($attr_name)
+        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
+            AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
+                               [Define to necessary symbol if this constant
+                                uses a non-standard name on your system.])
+        fi
+
+        AC_MSG_CHECKING([if more special flags are required for pthreads])
+        flag=no
+        case ${host_os} in
+            aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";;
+            osf* | hpux*) flag="-D_REENTRANT";;
+            solaris*)
+            if test "$GCC" = "yes"; then
+                flag="-D_REENTRANT"
+            else
+                flag="-mt -D_REENTRANT"
+            fi
+            ;;
+        esac
+        AC_MSG_RESULT(${flag})
+        if test "x$flag" != xno; then
+            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
+        fi
+
+        AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
+            ax_cv_PTHREAD_PRIO_INHERIT, [
+                AC_LINK_IFELSE([
+                    AC_LANG_PROGRAM([[#include <pthread.h>]], [[int i = PTHREAD_PRIO_INHERIT;]])],
+                    [ax_cv_PTHREAD_PRIO_INHERIT=yes],
+                    [ax_cv_PTHREAD_PRIO_INHERIT=no])
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"],
+            AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.]))
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        # More AIX lossage: compile with *_r variant
+        if test "x$GCC" != xyes; then
+            case $host_os in
+                aix*)
+                AS_CASE(["x/$CC"],
+                  [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
+                  [#handle absolute path differently from PATH based program lookup
+                   AS_CASE(["x$CC"],
+                     [x/*],
+                     [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])],
+                     [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])
+                ;;
+            esac
+        fi
+fi
+
+test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
+
+AC_SUBST(PTHREAD_LIBS)
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_CC)
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test x"$ax_pthread_ok" = xyes; then
+        ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
+        :
+else
+        ax_pthread_ok=no
+        $2
+fi
+AC_LANG_POP
+])dnl AX_PTHREAD

misc/DHTnodes

@@ -0,0 +1,8 @@
+192.254.75.98 33445 951C88B7E75C867418ACDB5D273821372BB5BD652740BCDF623A4FA293E75D2F
+37.187.46.132 33445 A9D98212B3F972BD11DA52BEB0658C326FCCC1BFD49F347F9C2D3D8B61E1B927
+144.76.60.215 33445 04119E835DF3E78BACF0F84235B300546AF8B936F035185E2A8E9E0A67C8924F
+23.226.230.47 33445 A09162D68618E742FFBCA1C2C70385E6679604B2D80EA6E84AD0996A1AC8A074
+37.187.20.216 33445 4FD54CFD426A338399767E56FD0F44F5E35FA8C38C8E87C8DC3FEAC0160F8E17    
+54.199.139.199 33445 7F9C31FE850E97CEFD4C4591DF93FC757C7C12549DDD55F8EEAECC34FE76C029    
+109.169.46.133 33445 7F31BFC93B8E4016A902144D0B110C3EA97CB7D43F1C4D21BCAE998A7C838821
+192.210.149.121 33445 F404ABAA1C99A9D37D61AB54898F56793E1DEF8BD46B1038B9D822E8460FAB67    

misc/DHTservers

@@ -1,2 +0,0 @@
-192.254.75.98 33445 FE3914F4616E227F29B2103450D6B55A836AD4BD23F97144E2C4ABE8D504FE1B
-2607:5600:284::2 33445 FE3914F4616E227F29B2103450D6B55A836AD4BD23F97144E2C4ABE8D504FE1B

misc/Makefile.am

@@ -1 +1 @@
-dist_pkgdata_DATA = DHTservers
+dist_pkgdata_DATA = DHTnodes

misc/toxic.conf

@@ -0,0 +1,23 @@
+# 24 or 12 hour time
+time:24;
+
+# 1 to enable autologging, 0 to disable
+autolog:0;
+
+# 1 to disbale terminal alerts on messages, 0 to enable
+disable_alerts:0;
+
+# maximum lines for chat window history
+history_size:700;
+
+# 1 to use native terminal colours, 0 to use toxic default colour theme
+colour_theme:0;
+
+# preferred audio input device; numbers correspond to /lsdev in
+audio_in_dev:0;
+
+# preferred audio output device; numbers correspond to /lsdev out
+audio_out_dev:0;
+
+# preferred path for downloads
+download_path:/home/USERNAME/Downloads/;

src/audio_call.c

@@ -0,0 +1,842 @@
+/*  audio_call.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "toxic.h"
+#include "windows.h"
+#include "audio_call.h"
+#include "chat_commands.h"
+#include "global_commands.h"
+#include "line_info.h"
+
+#include <curses.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#ifdef __APPLE__
+#include <OpenAL/al.h>
+#include <OpenAL/alc.h>
+#else
+#include <AL/al.h>
+#include <AL/alc.h>
+#endif
+
+#define _cbend pthread_exit(NULL)
+
+#define AUDIO_FRAME_SIZE (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000)
+
+#define MAX_CALLS 10
+
+#define _True 1
+#define _False 0
+
+typedef struct _DeviceIx {
+
+    ALCdevice *dhndl; /* Handle of device selected/opened */
+    ALCcontext *ctx; /* Device context */
+    const char *devices[MAX_DEVICES]; /* Container of available devices */
+    int size; /* Size of above container */
+    int dix; /* Index of default device */
+    int index; /* Current index */
+} DeviceIx;
+
+typedef struct _Call {
+    pthread_t ttid; /* Transmission thread id */
+    _Bool ttas; /* Transmission thread active status (0 - stopped, 1- running) */
+} Call;
+
+struct _ASettings {
+    DeviceIx device[2];
+
+    AudioError errors;
+
+    ToxAv *av;
+    
+    ToxAvCodecSettings cs;
+    
+    Call calls[MAX_CALLS];
+} ASettins;
+
+void callback_recv_invite ( int32_t call_index, void *arg );
+void callback_recv_ringing ( int32_t call_index, void *arg );
+void callback_recv_starting ( int32_t call_index, void *arg );
+void callback_recv_ending ( int32_t call_index, void *arg );
+void callback_recv_error ( int32_t call_index, void *arg );
+void callback_call_started ( int32_t call_index, void *arg );
+void callback_call_canceled ( int32_t call_index, void *arg );
+void callback_call_rejected ( int32_t call_index, void *arg );
+void callback_call_ended ( int32_t call_index, void *arg );
+void callback_requ_timeout ( int32_t call_index, void *arg );
+void callback_peer_timeout ( int32_t call_index, void *arg );
+
+
+static void print_err (ToxWindow *self, uint8_t *error_str)
+{
+    line_info_add(self, NULL, NULL, NULL, error_str, SYS_MSG, 0, 0);
+}
+
+/* Opens device under current index
+ */
+int device_open (ToxWindow *self, _Devices type)
+{
+    WINDOW *window = self->chatwin->history;
+
+    /* Do not error if no device */
+    if ( !ASettins.device[type].size ) return 0;
+
+    ALCdevice *prev_device = ASettins.device[type].dhndl;
+
+    uint8_t msg[MAX_STR_SIZE];
+    uint8_t *error = NULL;
+
+    if ( type == input ) {
+        ASettins.device[type].dhndl = alcCaptureOpenDevice(
+                                          ASettins.device[type].devices[ASettins.device[type].index],
+                                          av_DefaultSettings.audio_sample_rate,
+                                          AL_FORMAT_MONO16,
+                                          AUDIO_FRAME_SIZE * 4);
+
+        if (alcGetError(ASettins.device[type].dhndl) != AL_NO_ERROR) {
+
+            /* Now check if we have previous device and act acording to it */
+            if ( !prev_device ) {
+                error = "Error starting input device!";
+
+                ASettins.errors |= ErrorStartingCaptureDevice;
+            } else {
+                error = "Could not start input device, falling back to previous";
+
+                /* NOTE: What if device is opened? */
+                ASettins.device[type].dhndl = prev_device;
+            }
+        } else {
+            /* Close previous */
+            if ( prev_device )
+                alcCaptureCloseDevice(prev_device);
+
+            if ( window ) {
+                snprintf(msg, sizeof(msg), "Input device: %s", ASettins.device[type].devices[ASettins.device[type].index]);
+                line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+            }
+        }
+
+        ASettins.device[type].ctx = NULL;
+    } else {
+        ASettins.device[type].dhndl = alcOpenDevice(ASettins.device[type].devices[ASettins.device[type].index]);
+
+        if (alcGetError(ASettins.device[type].dhndl) != AL_NO_ERROR) {
+
+            /* Now check if we have previous device and act acording to it */
+            if ( !prev_device ) {
+                error = "Error starting output device!";
+
+                ASettins.errors |= ErrorStartingOutputDevice;
+                ASettins.device[type].ctx = NULL;
+            } else {
+                error = "Could not start output device, falling back to previous";
+
+                /* NOTE: What if device is opened? */
+                ASettins.device[type].dhndl = prev_device;
+            }
+        } else {
+
+            /* Close previous */
+            if ( prev_device ) {
+                alcCaptureCloseDevice(prev_device);
+                alcMakeContextCurrent(NULL);
+                alcDestroyContext(ASettins.device[type].ctx);
+            }
+
+            ASettins.device[type].ctx = alcCreateContext(ASettins.device[type].dhndl, NULL);
+
+            if ( window ) {
+                snprintf(msg, sizeof(msg), "Output device: %s", ASettins.device[type].devices[ASettins.device[type].index]);
+                line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+            }
+        }
+    }
+
+    if ( error ) {
+        if ( window ) {
+            snprintf(msg, sizeof(msg), "Error: %s", error);
+            line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        }
+
+        return -1;
+    } else return 0;
+}
+
+int device_close (ToxWindow *self, _Devices type)
+{
+    /* Only close if device opened */
+    if ( ASettins.device[type].dhndl ) {
+        uint8_t *device = NULL;
+        
+        if (type == input) {
+            alcCaptureCloseDevice(ASettins.device[type].dhndl);
+            device = "input";
+        } else {
+            alcCloseDevice(ASettins.device[type].dhndl);
+            alcMakeContextCurrent(NULL);
+
+            if ( ASettins.device[type].ctx )
+                alcDestroyContext(ASettins.device[type].ctx);
+
+            device = "output";
+        }
+
+        ASettins.device[type].index = ASettins.device[type].dix;
+
+        if ( device == NULL ) {
+            return -1;
+        }
+        
+        if ( self ) {
+            uint8_t msg[MAX_STR_SIZE];
+            snprintf(msg, sizeof(msg), "Closed %s device", device);
+            line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        }
+    }
+    
+    return 0;
+}
+
+
+int device_set(ToxWindow *self, _Devices type, long int selection)
+{
+    uint8_t str[MAX_STR_SIZE];
+    uint8_t *s_type = type == input ? "input" : "output";
+    
+    if ( selection < 0 || selection >= ASettins.device[type].size ) {
+        snprintf(str, sizeof(str), "Cannot set audio %s device: Invalid index: %ld", s_type, selection);
+        line_info_add(self, NULL, NULL, NULL, str, SYS_MSG, 0, 0);
+        return -1;
+    }
+
+    ASettins.device[type].index = selection;
+    
+    if ( device_open(self, type) != 0 ) {
+        snprintf(str, sizeof(str), "Cannot open audio %s device index: %ld", s_type, selection);
+        line_info_add(self, NULL, NULL, NULL, str, SYS_MSG, 0, 0);
+        return -1;
+    }
+    
+    return 0;
+}
+
+
+ToxAv *init_audio(ToxWindow *self, Tox *tox)
+{    
+    ASettins.cs = av_DefaultSettings;
+    ASettins.cs.video_height = ASettins.cs.video_width = 0;
+    
+    ASettins.errors = NoError;
+    
+    memset(ASettins.calls, 0, sizeof(Call) * 10);
+
+    /* Capture devices */
+    const char *stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
+    ASettins.device[input].size = 0;
+
+    if ( stringed_device_list ) {
+        const char *default_device = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+
+        for ( ; *stringed_device_list; ++ASettins.device[input].size ) {
+            ASettins.device[input].devices[ASettins.device[input].size] = stringed_device_list;
+
+            if ( strcmp( default_device , ASettins.device[input].devices[ASettins.device[input].size] ) == 0 )
+                ASettins.device[input].index = ASettins.device[input].dix = ASettins.device[input].size;
+
+            stringed_device_list += strlen( stringed_device_list ) + 1;
+        }
+    }
+
+
+    /* Output devices */
+    stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+    ASettins.device[output].size = 0;
+
+    if ( stringed_device_list ) {
+        const char *default_device = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+
+        for ( ; *stringed_device_list; ++ASettins.device[output].size ) {
+            ASettins.device[output].devices[ASettins.device[output].size] = stringed_device_list;
+
+            if ( strcmp( default_device , ASettins.device[output].devices[ASettins.device[output].size] ) == 0 )
+                ASettins.device[output].index = ASettins.device[output].dix = ASettins.device[output].size;
+
+            stringed_device_list += strlen( stringed_device_list ) + 1;
+        }
+    }
+
+    if (!ASettins.device[input].size && !ASettins.device[output].size) {
+        uint8_t *msg = "No devices: disabling audio!";
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        ASettins.av = NULL;
+    } else {
+        /* Streaming stuff from core */
+
+        ASettins.av = toxav_new(tox, MAX_CALLS);
+
+        if ( !ASettins.av ) {
+            ASettins.errors |= ErrorStartingCoreAudio;
+            return NULL;
+        }
+
+        toxav_register_callstate_callback(callback_call_started, av_OnStart, self);
+        toxav_register_callstate_callback(callback_call_canceled, av_OnCancel, self);
+        toxav_register_callstate_callback(callback_call_rejected, av_OnReject, self);
+        toxav_register_callstate_callback(callback_call_ended, av_OnEnd, self);
+        toxav_register_callstate_callback(callback_recv_invite, av_OnInvite, self);
+
+        toxav_register_callstate_callback(callback_recv_ringing, av_OnRinging, self);
+        toxav_register_callstate_callback(callback_recv_starting, av_OnStarting, self);
+        toxav_register_callstate_callback(callback_recv_ending, av_OnEnding, self);
+
+        toxav_register_callstate_callback(callback_recv_error, av_OnError, self);
+        toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, self);
+        toxav_register_callstate_callback(callback_peer_timeout, av_OnPeerTimeout, self);
+    }
+
+    return ASettins.av;
+}
+
+void terminate_audio()
+{
+    int i;
+    for (i = 0; i < MAX_CALLS; i ++)
+        stop_transmission(i);
+
+    if ( ASettins.av )
+        toxav_kill(ASettins.av);
+    
+    device_close(NULL, input);
+    device_close(NULL, output);
+}
+
+int errors()
+{
+    return ASettins.errors;
+}
+
+
+
+/*
+ * Transmission
+ */
+
+void *transmission(void *arg)
+{    
+    ToxWindow* self = arg;
+    int32_t call_index = self->call_index; 
+
+    /* Missing audio support */
+    if ( !ASettins.av ) _cbend;
+
+    Call* this_call = &ASettins.calls[call_index];
+    
+    this_call->ttas = _True;
+
+    /* Prepare devices */
+    alcCaptureStart(ASettins.device[input].dhndl);
+    alcMakeContextCurrent(ASettins.device[output].ctx);
+    
+    int32_t dec_frame_len;
+    int16_t frame[4096];
+    int32_t sample = 0;
+    uint32_t buffer;
+    int32_t ready;
+    int32_t openal_buffers = 5;
+    uint32_t source, *buffers;
+    uint8_t encoded_payload[RTP_PAYLOAD_SIZE];
+    const int32_t frame_size = AUDIO_FRAME_SIZE;
+    
+    /* Prepare buffers */
+    buffers = calloc(sizeof(uint32_t), openal_buffers);
+    alGenBuffers(openal_buffers, buffers);
+    alGenSources((uint32_t)1, &source);
+    alSourcei(source, AL_LOOPING, AL_FALSE);
+
+    uint16_t zeros[frame_size];
+    memset(zeros, 0, frame_size);
+    int16_t PCM[frame_size];
+
+    int32_t i = 0;
+
+    for (; i < openal_buffers; ++i) {
+        alBufferData(buffers[i], AL_FORMAT_MONO16, zeros, frame_size, 48000);
+    }
+
+    alSourceQueueBuffers(source, openal_buffers, buffers);
+    alSourcePlay(source);
+    
+    if (alGetError() != AL_NO_ERROR) {
+        /* Print something? */
+        /*fprintf(stderr, "Error starting audio\n");*/
+        
+//         goto cleanup;
+    }
+
+    /* Start transmission */
+    while (this_call->ttas) {
+
+        alcGetIntegerv(ASettins.device[input].dhndl, ALC_CAPTURE_SAMPLES, (int32_t) sizeof(int32_t), &sample);
+
+        /* RECORD AND SEND */
+        if (sample >= frame_size) {
+            alcCaptureSamples(ASettins.device[input].dhndl, frame, frame_size);
+            
+            int32_t payload_size = toxav_prepare_audio_frame(ASettins.av, call_index, encoded_payload, RTP_PAYLOAD_SIZE, frame, frame_size);
+            if ( payload_size <= 0 || toxav_send_audio(ASettins.av, call_index, encoded_payload, payload_size) < 0 ) {
+                /*fprintf(stderr, "Could not encode audio packet\n");*/
+            }
+        }
+
+        /* PLAYBACK */
+
+        alGetSourcei(source, AL_BUFFERS_PROCESSED, &ready);
+
+        if (ready <= 0) continue;
+
+        dec_frame_len = toxav_recv_audio(ASettins.av, call_index, frame_size, PCM);
+
+        /* Play the packet */
+        if (dec_frame_len > 0) {
+            alSourceUnqueueBuffers(source, 1, &buffer);
+            alBufferData(buffer, AL_FORMAT_MONO16, PCM, dec_frame_len * 2 * 1, 48000);
+            int32_t error = alGetError();
+
+            if (error != AL_NO_ERROR) {
+                fprintf(stderr, "Error setting buffer %d\n", error);
+                break;
+            }
+
+            alSourceQueueBuffers(source, 1, &buffer);
+
+            if (alGetError() != AL_NO_ERROR) {
+                fprintf(stderr, "Error: could not buffer audio\n");
+                break;
+            }
+
+            alGetSourcei(source, AL_SOURCE_STATE, &ready);
+
+            if (ready != AL_PLAYING) alSourcePlay(source);
+        }
+        else {
+            /* Error ignored */
+        }
+
+        usleep(1000);
+    }
+
+cleanup:
+
+    alDeleteSources(1, &source);
+    alDeleteBuffers(openal_buffers, buffers);
+    /*
+    device_close(NULL, input);
+    device_close(NULL, output);*/
+
+    _cbend;
+}
+
+int start_transmission(ToxWindow *self)
+{
+    if ( !ASettins.av || self->call_index == -1 ) return -1;
+    
+    /* Don't provide support for video */
+    if ( 0 != toxav_prepare_transmission(ASettins.av, self->call_index, &ASettins.cs, 0) ) {
+        line_info_add(self, NULL, NULL, NULL, "Could not prepare transmission", SYS_MSG, 0, 0);
+    }
+    
+    if ( !toxav_capability_supported(ASettins.av, self->call_index, AudioDecoding) ||
+         !toxav_capability_supported(ASettins.av, self->call_index, AudioEncoding) )
+        return -1;
+
+    if ( 0 != pthread_create(&ASettins.calls[self->call_index].ttid, NULL, transmission, self ) &&
+         0 != pthread_detach(ASettins.calls[self->call_index].ttid) ) {
+        return -1;
+    }
+}
+
+int stop_transmission(int call_index)
+{    
+    toxav_kill_transmission(ASettins.av, call_index);
+    ASettins.calls[call_index].ttas = _False;
+}
+/*
+ * End of transmission
+ */
+
+
+
+
+
+/*
+ * Callbacks
+ */
+
+#define CB_BODY(call_idx, Arg, onFunc) do { ToxWindow* windows = (Arg); int i;\
+for (i = 0; i < MAX_WINDOWS_NUM; ++i) if (windows[i].onFunc != NULL) windows[i].onFunc(&windows[i], ASettins.av, call_idx); } while (0)
+
+void callback_recv_invite ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onInvite);
+}
+void callback_recv_ringing ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onRinging);
+}
+void callback_recv_starting ( int32_t call_index, void* arg )
+{
+    ToxWindow* windows = arg; 
+    int i;
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) 
+        if (windows[i].onStarting != NULL && windows[i].call_index == call_index) { 
+            windows[i].onStarting(&windows[i], ASettins.av, call_index);
+            if ( 0 != start_transmission(&windows[i]) ) {/* YEAH! */
+                line_info_add(&windows[i], NULL, NULL, NULL, "Error starting transmission!", SYS_MSG, 0, 0);
+                return;
+            }
+        }
+    
+}
+void callback_recv_ending ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onEnding);
+    stop_transmission(call_index);
+}
+void callback_recv_error ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onError);
+}
+void callback_call_started ( int32_t call_index, void* arg )
+{    
+    ToxWindow* windows = arg; 
+    int i;
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) 
+        if (windows[i].onStart != NULL && windows[i].call_index == call_index) { 
+            windows[i].onStart(&windows[i], ASettins.av, call_index);
+            if ( 0 != start_transmission(&windows[i]) ) {/* YEAH! */
+                line_info_add(&windows[i], NULL, NULL, NULL, "Error starting transmission!", SYS_MSG, 0, 0);
+                return;
+            }
+        }
+}
+void callback_call_canceled ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onCancel);
+
+    /* In case call is active */
+    stop_transmission(call_index);
+}
+void callback_call_rejected ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onReject);
+}
+void callback_call_ended ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onEnd);
+    stop_transmission(call_index);
+}
+
+void callback_requ_timeout ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onRequestTimeout);
+}
+void callback_peer_timeout ( int32_t call_index, void* arg )
+{
+    CB_BODY(call_index, arg, onPeerTimeout);
+    stop_transmission(call_index);
+    /* Call is stopped manually since there might be some other
+     * actions that one can possibly take on timeout
+     */
+    toxav_stop_call(ASettins.av, call_index);
+}
+/*
+ * End of Callbacks
+ */
+
+
+/*
+ * Commands from chat_commands.h
+ */
+void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t msg[MAX_STR_SIZE];
+    uint8_t *error_str;
+
+    if (argc != 0) {
+        error_str = "Invalid syntax!";
+        goto on_error;
+    }
+
+    if ( !ASettins.av ) {
+        error_str = "Audio not supported!";
+        goto on_error;
+    }
+
+    ToxAvError error = toxav_call(ASettins.av, &self->call_index, self->num, TypeAudio, 30);
+
+    if ( error != ErrorNone ) {
+        if ( error == ErrorAlreadyInCall ) error_str = "Already in a call!";
+        else error_str = "Internal error!";
+
+        goto on_error;
+    }
+
+    snprintf(msg, sizeof(msg), "Calling... idx: %d", self->call_index);
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+
+    return;
+on_error:
+    snprintf(msg, sizeof(msg), "%s", error_str);
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+}
+
+void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t *error_str;
+
+    if (argc != 0) {
+        error_str = "Invalid syntax!";
+        goto on_error;
+    }
+
+    if ( !ASettins.av ) {
+        error_str = "Audio not supported!";
+        goto on_error;
+    }
+
+    ToxAvError error = toxav_answer(ASettins.av, self->call_index, TypeAudio);
+
+    if ( error != ErrorNone ) {
+        if ( error == ErrorInvalidState ) error_str = "Cannot answer in invalid state!";
+        else if ( error == ErrorNoCall ) error_str = "No incoming call!";
+        else error_str = "Internal error!";
+
+        goto on_error;
+    }
+
+    /* Callback will print status... */
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+void cmd_reject(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t *error_str;
+
+    if (argc != 0) {
+        error_str = "Invalid syntax!";
+        goto on_error;
+    }
+
+    if ( !ASettins.av ) {
+        error_str = "Audio not supported!";
+        goto on_error;
+    }
+
+    ToxAvError error = toxav_reject(ASettins.av, self->call_index, "Why not?");
+
+    if ( error != ErrorNone ) {
+        if ( error == ErrorInvalidState ) error_str = "Cannot reject in invalid state!";
+        else if ( error == ErrorNoCall ) error_str = "No incoming call!";
+        else error_str = "Internal error!";
+
+        goto on_error;
+    }
+
+    /* Callback will print status... */
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t *error_str;
+
+    if (argc != 0) {
+        error_str = "Invalid syntax!";
+        goto on_error;
+    }
+
+    if ( !ASettins.av ) {
+        error_str = "Audio not supported!";
+        goto on_error;
+    }
+
+    ToxAvError error = toxav_hangup(ASettins.av, self->call_index);
+
+    if ( error != ErrorNone ) {
+        if ( error == ErrorInvalidState ) error_str = "Cannot hangup in invalid state!";
+        else if ( error == ErrorNoCall ) error_str = "No call!";
+        else error_str = "Internal error!";
+
+        goto on_error;
+    }
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+void cmd_cancel(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t *error_str;
+
+    if (argc != 0) {
+        error_str = "Invalid syntax!";
+        goto on_error;
+    }
+
+    if ( !ASettins.av ) {
+        error_str = "Audio not supported!";
+        goto on_error;
+    }
+
+    ToxAvError error = toxav_cancel(ASettins.av, self->call_index, self->num,
+                                    "Only those who appreciate small things know the beauty that is life");
+
+    if ( error != ErrorNone ) {
+        if ( error == ErrorNoCall ) error_str = "No call!";
+        else error_str = "Internal error!";
+
+        goto on_error;
+    }
+
+    /* Callback will print status... */
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+
+void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t msg[MAX_STR_SIZE];
+    uint8_t *error_str;
+
+    if ( argc != 1 ) {
+        if ( argc < 1 ) error_str = "Type must be specified!";
+        else error_str = "Only one argument allowed!";
+
+        goto on_error;
+    }
+
+    _Devices type;
+
+    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+        type = input;
+
+    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+        type = output;
+
+    else {
+        snprintf(msg, sizeof(msg), "Invalid type: %s", argv[1]);
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        return;
+    }
+
+    int i = 0;
+
+    for ( ; i < ASettins.device[type].size; i ++) {
+        snprintf(msg, sizeof(msg), "%d: %s", i, ASettins.device[type].devices[i]);
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+    }
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t msg[MAX_STR_SIZE];
+    uint8_t *error_str;
+
+    if ( argc != 2 ) {
+        if ( argc < 1 ) error_str = "Type must be specified!";
+        else if ( argc < 2 ) error_str = "Must have id!";
+        else error_str = "Only two arguments allowed!";
+
+        goto on_error;
+    }
+
+    if ( ASettins.calls[self->call_index].ttas ) { /* Transmission is active */
+        error_str = "Cannot change device while active transmission";
+        goto on_error;
+    }
+
+    _Devices type;
+
+    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+        type = input;
+
+    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+        type = output;
+
+    else {
+        snprintf(msg, sizeof(msg), "Invalid type: %s", argv[1]);
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        return;
+    }
+
+
+    char *end;
+    long int selection = strtol(argv[2], &end, 10);
+
+    if ( *end ) {
+        error_str = "Invalid input";
+        goto on_error;
+    }
+    
+    if ( device_close(self, type) != 0 ) {
+        error_str = "Could not close device!";
+        goto on_error;
+    }
+    
+    if ( device_set(self, type, selection ) == 0) {
+        /*snprintf(msg, sizeof(msg), "Selected: %s", ASettins.device[type].devices[selection]);
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);*/
+    }
+    
+    if ( device_open(self, type) == 0 ) {
+        snprintf(msg, sizeof(msg), "Now using: %s", ASettins.device[type].devices[selection]);
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+    }
+    
+    return;
+on_error:
+    print_err (self, error_str);
+}

src/audio_call.h

@@ -0,0 +1,56 @@
+/*  audio_call.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _audio_h
+#define _audio_h
+
+#include <tox/toxav.h>
+
+#include "toxic.h"
+#include "windows.h"
+
+#define MAX_DEVICES 32
+
+typedef enum _AudioError {
+    NoError = 0,
+    ErrorStartingCaptureDevice = 1 << 0,
+    ErrorStartingOutputDevice = 1 << 1,
+    ErrorStartingCoreAudio = 1 << 2
+} AudioError;
+
+typedef enum _Devices {
+    input,
+    output,
+} _Devices;
+
+/* You will have to pass pointer to first member of 'windows'
+ * declared in windows.c otherwise undefined behaviour will
+ */
+ToxAv *init_audio(ToxWindow *self, Tox *tox);
+void terminate_audio();
+
+int errors();
+
+int start_transmission(ToxWindow *self);
+int device_set(ToxWindow *self, _Devices type, long int selection);
+
+#endif /* _audio_h */

src/chat.h

@@ -1,8 +1,32 @@
+/*  chat.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
 #ifndef CHAT_H_6489PZ13
 #define CHAT_H_6489PZ13
 
-#include "toxic_windows.h"
+#include "windows.h"
+#include "toxic.h"
 
-ToxWindow new_chat(Tox *m, int friendnum);
+void kill_chat_window(ToxWindow *self);
+ToxWindow new_chat(Tox *m, int32_t friendnum);
 
 #endif /* end of include guard: CHAT_H_6489PZ13 */

src/chat_commands.c

@@ -1,5 +1,23 @@
-/*
- * Toxic -- Tox Curses Client
+/*  chat_commands.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
 #ifdef HAVE_CONFIG_H
@@ -9,9 +27,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "toxic_windows.h"
+#include "toxic.h"
+#include "windows.h"
 #include "misc_tools.h"
 #include "friendlist.h"
+#include "execute.h"
+#include "line_info.h"
 
 extern ToxWindow *prompt;
 
@@ -22,76 +43,114 @@ extern uint8_t max_file_senders_index;
 
 void cmd_chat_help(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    wattron(window, COLOR_PAIR(CYAN) | A_BOLD);
-    wprintw(window, "Chat commands:\n");
-    wattroff(window, COLOR_PAIR(CYAN) | A_BOLD);
+    struct history *hst = self->chatwin->hst;
+    line_info_clear(hst);
+    struct line_info *start = hst->line_start;
 
-    wprintw(window, "      /status <type> <msg>       : Set your status with optional note\n");
-    wprintw(window, "      /note <msg>                : Set a personal note\n");
-    wprintw(window, "      /nick <nick>               : Set your nickname\n");
-    wprintw(window, "      /invite <n>                : Invite friend to a group chat\n");
-    wprintw(window, "      /me <action>               : Do an action\n");
-    wprintw(window, "      /myid                      : Print your ID\n");
-    wprintw(window, "      /join                      : Join a pending group chat\n");
-    wprintw(window, "      /clear                     : Clear the screen\n");
-    wprintw(window, "      /close                     : Close the current chat window\n");
-    wprintw(window, "      /sendfile <filepath>       : Send a file\n");
-    wprintw(window, "      /savefile <n>              : Receive a file\n");
-    wprintw(window, "      /quit or /exit             : Exit Toxic\n");
-    wprintw(window, "      /help                      : Print this message again\n");
+    if (argc == 1) {
+        if (!strcmp(argv[1], "global")) {
+            execute(window, self, m, "/help", GLOBAL_COMMAND_MODE);
+            return;
+        }
+    }
 
-    wattron(window, COLOR_PAIR(CYAN) | A_BOLD);
-    wprintw(window, " * Argument messages must be enclosed in quotation marks.\n\n");
-    wattroff(window, COLOR_PAIR(CYAN) | A_BOLD);
+    uint8_t *msg = "Chat commands:";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
+
+#ifdef _SUPPORT_AUDIO
+#define NUMLINES 13
+#else
+#define NUMLINES 9
+#endif
+
+    uint8_t lines[NUMLINES][MAX_STR_SIZE] = {
+
+#ifdef _SUPPORT_AUDIO
+        { "    /call                      : Audio call"                           },
+        { "    /cancel                    : Cancel call"                          },
+        { "    /answer                    : Answer incomming call"                },
+        { "    /reject                    : Reject incoming call"                 },
+        { "    /hangup                    : Hangup active call"                   },
+#endif /* _SUPPORT_AUDIO */
+        { "    /invite <n>                : Invite friend to a group chat"        },
+        { "    /join                      : Join a pending group chat"            },
+        { "    /log <on> or <off>         : Enable/disable logging"               },
+        { "    /sendfile <filepath>       : Send a file"                          },
+        { "    /savefile <n>              : Receive a file"                       },
+        { "    /close                     : Close the current chat window"        },
+        { "    /help                      : Print this message again"             },
+        { "    /help global               : Show a list of global commands"       },
+    };
+
+    int i;
+
+    for (i = 0; i < NUMLINES; ++i)
+        line_info_add(self, NULL, NULL, NULL, lines[i], SYS_MSG, 0, 0);
+
+    msg = " * Use Page Up/Page Down to scroll chat history\n";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
+
+    hst->line_start = start;
 }
 
 void cmd_groupinvite(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    uint8_t *errmsg;
+
     if (argc < 1) {
-      wprintw(window, "Invalid syntax.\n");
+        errmsg = "Invalid syntax";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     int groupnum = atoi(argv[1]);
 
     if (groupnum == 0 && strcmp(argv[1], "0")) {    /* atoi returns 0 value on invalid input */
-        wprintw(window, "Invalid syntax.\n");
+        errmsg = "Invalid syntax.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     if (tox_invite_friend(m, self->num, groupnum) == -1) {
-        wprintw(window, "Failed to invite friend.\n");
+        errmsg = "Failed to invite friend.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
-    wprintw(window, "Invited friend to group chat %d.\n", groupnum);
+    uint8_t msg[MAX_STR_SIZE];
+    snprintf(msg, sizeof(msg), "Invited friend to Room #%d.", groupnum);
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
 }
 
 void cmd_join_group(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    if (num_active_windows() >= MAX_WINDOWS_NUM) {
-        wattron(window, COLOR_PAIR(RED));
-        wprintw(window, " * Warning: Too many windows are open.\n");
-        wattron(window, COLOR_PAIR(RED));
+    uint8_t *errmsg;
+
+    if (get_num_active_windows() >= MAX_WINDOWS_NUM) {
+        errmsg = " * Warning: Too many windows are open.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, RED);
         return;
     }
 
     uint8_t *groupkey = friends[self->num].pending_groupchat;
 
     if (groupkey[0] == '\0') {
-        wprintw(window, "No pending group chat invite.\n");
+        errmsg = "No pending group chat invite.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     int groupnum = tox_join_groupchat(m, self->num, groupkey);
 
     if (groupnum == -1) {
-        wprintw(window, "Group chat instance failed to initialize.\n");
+        errmsg = "Group chat instance failed to initialize.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     if (init_groupchat_win(prompt, m, groupnum) == -1) {
-        wprintw(window, "Group chat window failed to initialize.\n");
+        errmsg = "Group chat window failed to initialize.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         tox_del_groupchat(m, groupnum);
         return;
     }
@@ -99,64 +158,87 @@ void cmd_join_group(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*ar
 
 void cmd_savefile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    uint8_t *errmsg;
+
     if (argc != 1) {
-      wprintw(window, "Invalid syntax.\n");
+        errmsg = "Invalid syntax.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     uint8_t filenum = atoi(argv[1]);
 
     if ((filenum == 0 && strcmp(argv[1], "0")) || filenum >= MAX_FILES) {
-        wprintw(window, "No pending file transfers with that number.\n");
+        errmsg = "No pending file transfers with that number.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     if (!friends[self->num].file_receiver.pending[filenum]) {
-        wprintw(window, "No pending file transfers with that number.\n");
+        errmsg = "No pending file transfers with that number.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     uint8_t *filename = friends[self->num].file_receiver.filenames[filenum];
 
-    if (tox_file_send_control(m, self->num, 1, filenum, TOX_FILECONTROL_ACCEPT, 0, 0) == 0)
-        wprintw(window, "Accepted file transfer %u. Saving file as: '%s'\n", filenum, filename);
-    else
-        wprintw(window, "File transfer failed.\n");
+    if (tox_file_send_control(m, self->num, 1, filenum, TOX_FILECONTROL_ACCEPT, 0, 0) == 0) {
+        uint8_t msg[MAX_STR_SIZE];
+        snprintf(msg, sizeof(msg), "Saving file as: '%s' (%.1f%%)", filename, 0.0);
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        friends[self->num].file_receiver.line_id[filenum] = self->chatwin->hst->line_end->id + 1;
+
+        if ((friends[self->num].file_receiver.files[filenum] = fopen(filename, "a")) == NULL) {
+            errmsg = "* Error writing to file.";
+            line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, RED);
+            tox_file_send_control(m, self->num, 1, filenum, TOX_FILECONTROL_KILL, 0, 0);
+        }
+    } else {
+        errmsg = "File transfer failed.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
+    }
 
     friends[self->num].file_receiver.pending[filenum] = false;
 }
 
 void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    if (max_file_senders_index >= (MAX_FILES-1)) {
-        wprintw(window,"Please wait for some of your outgoing file transfers to complete.\n");
+    uint8_t *errmsg;
+
+    if (max_file_senders_index >= (MAX_FILES - 1)) {
+        errmsg = "Please wait for some of your outgoing file transfers to complete.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     if (argc < 1) {
-      wprintw(window, "Invalid syntax.\n");
+        errmsg = "Invalid syntax.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     uint8_t *path = argv[1];
 
     if (path[0] != '\"') {
-        wprintw(window, "File path must be enclosed in quotes.\n");
+        errmsg = "File path must be enclosed in quotes.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
-    path[strlen(++path)-1] = L'\0';
+    path[strlen(++path) - 1] = L'\0';
     int path_len = strlen(path);
 
     if (path_len > MAX_STR_SIZE) {
-        wprintw(window, "File path exceeds character limit.\n");
+        errmsg = "File path exceeds character limit.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     FILE *file_to_send = fopen(path, "r");
 
     if (file_to_send == NULL) {
-        wprintw(window, "File '%s' not found.\n", path);
+        errmsg = "File not found.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
@@ -165,11 +247,12 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
     fseek(file_to_send, 0, SEEK_SET);
 
     uint8_t filename[MAX_STR_SIZE];
-    get_file_name(path, filename);
-    int filenum = tox_new_file_sender(m, self->num, filesize, filename, strlen(filename) + 1);
+    get_file_name(filename, path);
+    int filenum = tox_new_file_sender(m, self->num, filesize, filename, strlen(filename));
 
     if (filenum == -1) {
-        wprintw(window, "Error sending file.\n");
+        errmsg = "Error sending file.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
@@ -181,13 +264,16 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
             file_senders[i].active = true;
             file_senders[i].toxwin = self;
             file_senders[i].file = file_to_send;
-            file_senders[i].filenum = (uint8_t) filenum;
+            file_senders[i].filenum = filenum;
             file_senders[i].friendnum = self->num;
-            file_senders[i].timestamp = (uint64_t) time(NULL);
+            file_senders[i].timestamp = get_unix_time();
+            file_senders[i].size = filesize;
             file_senders[i].piecelen = fread(file_senders[i].nextpiece, 1,
                                              tox_file_data_size(m, self->num), file_to_send);
 
-            wprintw(window, "Sending file: '%s'\n", path);
+            uint8_t msg[MAX_STR_SIZE];
+            snprintf(msg, sizeof(msg), "Sending file: '%s'", path);
+            line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
 
             if (i == max_file_senders_index)
                 ++max_file_senders_index;

src/chat_commands.h

@@ -1,9 +1,44 @@
-/*
- * Toxic -- Tox Curses Client
+/*  chat_commands.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
+#ifndef _chat_commands_h
+#define _chat_commands_h
+
+#include "windows.h"
+#include "toxic.h"
+
 void cmd_chat_help(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_groupinvite(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_join_group(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_savefile(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_sendfile(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+
+
+#ifdef _SUPPORT_AUDIO
+void cmd_call(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_answer(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_reject(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_hangup(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_cancel(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+#endif /* _SUPPORT_AUDIO */
+
+#endif /* #define _chat_commands_h */

src/configdir.c

@@ -1,20 +1,22 @@
-/*
- *  Copyright (C) 2013 Tox project All Rights Reserved.
+/*  configdir.c
  *
- *  This file is part of Tox.
  *
- *  Tox is free software: you can redistribute it and/or modify
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
- *  Tox is distributed in the hope that it will be useful,
+ *  Toxic is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
@@ -28,14 +30,8 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
-
-#ifdef _WIN32
-#include <shlobj.h>
-#include <direct.h>
-#else /* WIN32 */
 #include <unistd.h>
 #include <pwd.h>
-#endif /* WIN32 */
 
 #include "configdir.h"
 
@@ -49,25 +45,6 @@
 char *get_user_config_dir(void)
 {
     char *user_config_dir;
-#ifdef _WIN32
-#warning Please fix configdir for Win32
-    return NULL;
-#if 0
-    char appdata[MAX_PATH];
-    BOOL ok;
-
-    ok = SHGetSpecialFolderPathA(NULL, appdata, CSIDL_PROFILE, TRUE);
-
-    if (!ok) {
-        return NULL;
-    }
-
-    user_config_dir = strdup(appdata);
-
-    return user_config_dir;
-#endif
-
-#else /* WIN32 */
 
 #ifndef NSS_BUFLEN_PASSWD
 #define NSS_BUFLEN_PASSWD 4096
@@ -108,6 +85,7 @@ char *get_user_config_dir(void)
 # else /* __APPLE__ */
 
     const char *tmp;
+
     if (!(tmp = getenv("XDG_CONFIG_HOME"))) {
         len = strlen(home) + strlen("/.config") + 1;
         user_config_dir = malloc(len);
@@ -125,7 +103,6 @@ char *get_user_config_dir(void)
 
     return user_config_dir;
 #undef NSS_BUFLEN_PASSWD
-#endif /* WIN32 */
 }
 
 /*
@@ -133,26 +110,6 @@ char *get_user_config_dir(void)
  */
 int create_user_config_dir(char *path)
 {
-#ifdef _WIN32
-#warning Please fix configdir for Win32
-    return -1;
-#if 0
-    char *fullpath = malloc(strlen(path) + strlen(CONFIGDIR) + 1);
-    strcpy(fullpath, path);
-    strcat(fullpath, CONFIGDIR);
-
-    mkdir_err = _mkdir(fullpath);
-    struct __stat64 buf;
-
-    if (mkdir_err && (errno != EEXIST || _wstat64(fullpath, &buf) || !S_ISDIR(buf.st_mode))) {
-        free(fullpath);
-        return -1;
-    }
-
-    free(fullpath);
-#endif
-
-#else
     int mkdir_err;
 
     mkdir_err = mkdir(path, 0700);
@@ -175,5 +132,4 @@ int create_user_config_dir(char *path)
 
     free(fullpath);
     return 0;
-#endif
 }

src/configdir.h

@@ -1,28 +1,29 @@
-/*
- *  Copyright (C) 2013 Tox project All Rights Reserved.
+/*  configdir.h
  *
- *  This file is part of Tox.
  *
- *  Tox is free software: you can redistribute it and/or modify
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
- *  Tox is distributed in the hope that it will be useful,
+ *  Toxic is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
-#ifdef _win32
-#define CONFIGDIR "\\tox\\"
-#else
+#ifndef _configdir_h
+#define _configdir_h
+
 #define CONFIGDIR "/tox/"
-#endif
 
 #ifndef S_ISDIR
 #define S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)
@@ -31,3 +32,5 @@
 char *get_user_config_dir(void);
 
 int create_user_config_dir(char *path);
+
+#endif /* #define _configdir_h */

src/dns.c

@@ -0,0 +1,304 @@
+/*  dns.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <resolv.h>
+
+#include <tox/toxdns.h>
+
+#include "toxic.h"
+#include "windows.h"
+#include "line_info.h"
+#include "dns.h"
+#include "global_commands.h"
+#include "misc_tools.h"
+
+#define MAX_DNS_REQST_SIZE 256
+#define NUM_DNS3_SERVERS 2    /* must correspond to number of items in dns3_servers array */
+#define TOX_DNS3_TXT_PREFIX "v=tox3;id="
+#define DNS3_KEY_SZ 32
+
+/* TODO: process keys from key file instead of hard-coding like a noob */
+static struct dns3_server {
+    uint8_t *name;
+    uint8_t key[DNS3_KEY_SZ];
+} dns3_servers[] = {
+    {
+        "utox.org", 
+        { 
+          0xD3, 0x15, 0x4F, 0x65, 0xD2, 0x8A, 0x5B, 0x41, 0xA0, 0x5D, 0x4A, 0xC7, 0xE4, 0xB3, 0x9C, 0x6B,
+          0x1C, 0x23, 0x3C, 0xC8, 0x57, 0xFB, 0x36, 0x5C, 0x56, 0xE8, 0x39, 0x27, 0x37, 0x46, 0x2A, 0x12
+        }
+    },
+    {
+        "toxme.se",
+        {
+          0x5D, 0x72, 0xC5, 0x17, 0xDF, 0x6A, 0xEC, 0x54, 0xF1, 0xE9, 0x77, 0xA6, 0xB6, 0xF2, 0x59, 0x14,
+          0xEA, 0x4C, 0xF7, 0x27, 0x7A, 0x85, 0x02, 0x7C, 0xD9, 0xF5, 0x19, 0x6D, 0xF1, 0x7E, 0x0B, 0x13
+        }
+    },
+};
+
+static struct _thread_data {
+    ToxWindow *self;
+    uint8_t id_bin[TOX_FRIEND_ADDRESS_SIZE];
+    uint8_t addr[MAX_STR_SIZE];
+    uint8_t msg[MAX_STR_SIZE];
+    uint8_t busy;
+    Tox *m;
+} t_data;
+
+static struct _dns_thread {
+    pthread_t tid;
+    pthread_mutex_t lock;
+} dns_thread;
+
+static int dns_error(ToxWindow *self, uint8_t *errmsg)
+{
+    uint8_t msg[MAX_STR_SIZE];
+    snprintf(msg, sizeof(msg), "DNS lookup failed: %s", errmsg);
+
+    pthread_mutex_lock(&dns_thread.lock);
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+    pthread_mutex_unlock(&dns_thread.lock);
+
+    return -1;
+}
+
+static void kill_dns_thread(void *dns_obj)
+{
+    if (dns_obj)
+        tox_dns3_kill(dns_obj);
+
+    memset(&t_data, 0, sizeof(struct _thread_data));
+    pthread_exit(0);
+}
+
+/* puts TXT from dns response in buf. Returns length of TXT on success, -1 on fail.*/
+static int parse_dns_response(ToxWindow *self, u_char *answer, int ans_len, uint8_t *buf)
+{
+    uint8_t *ans_pt = answer + sizeof(HEADER);
+    uint8_t *ans_end = answer + ans_len;
+    uint8_t exp_ans[PACKETSZ];
+    
+    int len = dn_expand(answer, ans_end, ans_pt, exp_ans, sizeof(exp_ans));
+
+    if (len == -1)
+        return dns_error(self, "dn_expand failed."); 
+
+    ans_pt += len;
+
+    if (ans_pt > ans_end - 4)
+         return dns_error(self, "Reply was too short."); 
+
+    int type;
+    GETSHORT(type, ans_pt);
+
+    if (type != T_TXT)
+        return dns_error(self, "Broken reply."); 
+ 
+
+    ans_pt += INT16SZ;    /* class */
+    uint32_t size = 0;
+
+    /* recurse through CNAME rr's */
+    do { 
+        ans_pt += size;
+        len = dn_expand(answer, ans_end, ans_pt, exp_ans, sizeof(exp_ans));
+
+        if (len == -1)
+            return dns_error(self, "Second dn_expand failed."); 
+
+        ans_pt += len;
+
+        if (ans_pt > ans_end - 10)
+            return dns_error(self, "Reply was too short."); 
+
+        GETSHORT(type, ans_pt);
+        ans_pt += INT16SZ;
+        ans_pt += 4;
+        GETSHORT(size, ans_pt);
+
+        if (ans_pt + size < answer || ans_pt + size > ans_end)
+            return dns_error(self, "RR overflow."); 
+
+    } while (type == T_CNAME);
+
+    if (type != T_TXT)
+        return dns_error(self, "Not a TXT record."); 
+
+    uint32_t txt_len = *ans_pt;
+
+    if (!size || txt_len >= size || !txt_len)
+        return dns_error(self, "No record found.");
+
+    ans_pt++;
+    ans_pt[txt_len] = '\0';
+    memcpy(buf, ans_pt, txt_len + 1);
+
+    return txt_len;
+}
+
+/* Takes address addr in the form "username@domain", puts the username in namebuf, 
+   and the domain in dombuf.
+
+   return length of username on success, -1 on failure */
+static int parse_addr(uint8_t *addr, uint8_t *namebuf, uint8_t *dombuf)
+{
+    uint8_t tmpaddr[MAX_STR_SIZE];
+    uint8_t *tmpname, *tmpdom;
+
+    strcpy(tmpaddr, addr);
+    tmpname = strtok(tmpaddr, "@");
+    tmpdom = strtok(NULL, "");
+
+    if (tmpname == NULL || tmpdom == NULL)
+        return -1;
+
+    str_to_lower(tmpdom);
+    strcpy(namebuf, tmpname);
+    strcpy(dombuf, tmpdom);
+
+    return strlen(namebuf);
+}
+
+/* Does DNS lookup for addr and puts resulting tox id in id_bin. */
+void *dns3_lookup_thread(void *data)
+{
+    ToxWindow *self = t_data.self;
+
+    uint8_t domain[MAX_STR_SIZE];
+    uint8_t name[MAX_STR_SIZE];
+
+    int namelen = parse_addr(t_data.addr, name, domain);
+
+    if (namelen == -1) {
+        dns_error(self, "Must be a Tox ID or an address in the form username@domain");
+        kill_dns_thread(NULL);
+    }
+
+    /* get domain name/pub key */
+    uint8_t *DNS_pubkey, *domname = NULL;
+    int i;
+
+    for (i = 0; i < NUM_DNS3_SERVERS; ++i) {
+        if (strcmp(dns3_servers[i].name, domain) == 0) {
+            DNS_pubkey = dns3_servers[i].key;
+            domname = dns3_servers[i].name;
+            break;
+        }
+    }
+
+    if (domname == NULL) {
+        dns_error(self, "Domain not found.");
+        kill_dns_thread(NULL);
+    }
+
+    void *dns_obj = tox_dns3_new(DNS_pubkey);
+
+    if (dns_obj == NULL) {
+        dns_error(self, "Core failed to create DNS object.");
+        kill_dns_thread(NULL);
+    }
+
+    uint8_t string[MAX_DNS_REQST_SIZE];
+    uint32_t request_id;
+
+    int str_len = tox_generate_dns3_string(dns_obj, string, sizeof(string), &request_id, name, namelen);
+
+    if (str_len == -1) {
+        dns_error(self, "Core failed to generate dns3 string.");
+        kill_dns_thread(dns_obj);
+    }
+
+    string[str_len] = '\0';
+
+    u_char answer[PACKETSZ];
+    uint8_t d_string[MAX_DNS_REQST_SIZE];
+
+    /* format string and create dns query */
+    snprintf(d_string, sizeof(d_string), "_%s._tox.%s", string, domname);
+    int ans_len = res_query(d_string, C_IN, T_TXT, answer, sizeof(answer));
+
+    if (ans_len <= 0) {
+        dns_error(self, "Query failed.");
+        kill_dns_thread(dns_obj);
+    }
+
+    uint8_t ans_id[MAX_DNS_REQST_SIZE];
+
+    /* extract TXT from DNS response */
+    if (parse_dns_response(self, answer, ans_len, ans_id) == -1)
+        kill_dns_thread(dns_obj);
+
+    uint8_t encrypted_id[MAX_DNS_REQST_SIZE];
+    int prfx_len = strlen(TOX_DNS3_TXT_PREFIX);
+
+    /* extract the encrypted ID from TXT response */
+    if (strncmp(ans_id, TOX_DNS3_TXT_PREFIX, prfx_len) != 0) {
+        dns_error(self, "Bad dns3 TXT response.");
+        kill_dns_thread(dns_obj);
+    }
+
+    memcpy(encrypted_id, ans_id + prfx_len, ans_len - prfx_len);
+
+    if (tox_decrypt_dns3_TXT(dns_obj, t_data.id_bin, encrypted_id, strlen(encrypted_id), request_id) == -1) {
+        dns_error(self, "Core failed to decrypt response.");
+        kill_dns_thread(dns_obj);
+    }
+
+    pthread_mutex_lock(&dns_thread.lock);
+    cmd_add_helper(self, t_data.m, t_data.id_bin, t_data.msg);
+    pthread_mutex_unlock(&dns_thread.lock);
+
+    kill_dns_thread(dns_obj);
+}
+
+/* creates new thread for dns3 lookup. Only allows one lookup at a time. */
+void dns3_lookup(ToxWindow *self, Tox *m, uint8_t *id_bin, uint8_t *addr, uint8_t *msg)
+{
+    if (t_data.busy) {
+        uint8_t *err = "Please wait for previous user lookup to finish.";
+        line_info_add(self, NULL, NULL, NULL, err, SYS_MSG, 0, 0);
+        return;
+    }
+
+    t_data.self = self;
+    snprintf(t_data.id_bin, sizeof(t_data.id_bin), "%s", id_bin);
+    snprintf(t_data.addr, sizeof(t_data.addr), "%s", addr);
+    snprintf(t_data.msg, sizeof(t_data.msg), "%s", msg);
+    t_data.m = m;
+    t_data.busy = 1;
+
+    if (pthread_create(&dns_thread.tid, NULL, dns3_lookup_thread, NULL) != 0)
+        exit_toxic_err("failed in dns3_lookup", FATALERR_THREAD_CREATE);
+
+    if (pthread_mutex_init(&dns_thread.lock, NULL) != 0)
+        exit_toxic_err("failed in dns3_lookup", FATALERR_MUTEX_INIT);
+}

src/dns.h

@@ -0,0 +1,32 @@
+/*  dns.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/* Does DNS lookup for addr and puts resulting tox id in id_bin.
+   Return 0 on success, -1 on failure. */
+
+#ifndef _dns_h
+#define _dns_h
+
+/* creates new thread for dns3 lookup. Only allows one lookup at a time. */
+void dns3_lookup(ToxWindow *self, Tox *m, uint8_t *id_bin, uint8_t *addr, uint8_t *msg);
+
+#endif /* #define _dns_h */

src/execute.c

@@ -1,14 +1,39 @@
-/*
- * Toxic -- Tox Curses Client
+/*  execute.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
-#include "toxic_windows.h"
+#include "toxic.h"
+#include "windows.h"
 #include "execute.h"
 #include "chat_commands.h"
 #include "global_commands.h"
+#include "line_info.h"
 
 struct cmd_func {
     const char *name;
@@ -23,12 +48,18 @@ static struct cmd_func global_commands[] = {
     { "/exit",      cmd_quit          },
     { "/groupchat", cmd_groupchat     },
     { "/help",      cmd_prompt_help   },
+    { "/log",       cmd_log           },
     { "/myid",      cmd_myid          },
     { "/nick",      cmd_nick          },
     { "/note",      cmd_note          },
     { "/q",         cmd_quit          },
     { "/quit",      cmd_quit          },
     { "/status",    cmd_status        },
+
+#ifdef _SUPPORT_AUDIO
+    { "/lsdev",     cmd_list_devices  },
+    { "/sdev",      cmd_change_device },
+#endif /* _SUPPORT_AUDIO */
 };
 
 static struct cmd_func chat_commands[] = {
@@ -37,23 +68,32 @@ static struct cmd_func chat_commands[] = {
     { "/join",      cmd_join_group  },
     { "/savefile",  cmd_savefile    },
     { "/sendfile",  cmd_sendfile    },
+
+#ifdef _SUPPORT_AUDIO
+    { "/call",      cmd_call        },
+    { "/cancel",    cmd_cancel      },
+    { "/answer",    cmd_answer      },
+    { "/reject",    cmd_reject      },
+    { "/hangup",    cmd_hangup      },
+#endif /* _SUPPORT_AUDIO */
 };
 
 /* Parses input command and puts args into arg array.
    Returns number of arguments on success, -1 on failure. */
-static int parse_command(WINDOW *w, char *cmd, char (*args)[MAX_STR_SIZE])
+static int parse_command(WINDOW *w, ToxWindow *self, char *cmd, char (*args)[MAX_STR_SIZE])
 {
     int num_args = 0;
-    bool cmd_end = false;    // flags when we get to the end of cmd
-    char *end;               // points to the end of the current arg
+    bool cmd_end = false;    /* flags when we get to the end of cmd */
+    char *end;               /* points to the end of the current arg */
 
     /* characters wrapped in double quotes count as one arg */
     while (!cmd_end && num_args < MAX_NUM_ARGS) {
         if (*cmd == '\"') {
-            end = strchr(cmd+1, '\"');
+            end = strchr(cmd + 1, '\"');
 
             if (end++ == NULL) {    /* Increment past the end quote */
-                wprintw(w, "Invalid argument. Did you forget a closing \"?\n");
+                uint8_t *errmsg = "Invalid argument. Did you forget a closing \"?";
+                line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
                 return -1;
             }
 
@@ -82,7 +122,7 @@ static int do_command(WINDOW *w, ToxWindow *self, Tox *m, int num_args, int num_
 
     for (i = 0; i < num_cmds; ++i) {
         if (strcmp(args[0], commands[i].name) == 0) {
-            (commands[i].func)(w, self, m, num_args-1, args);
+            (commands[i].func)(w, self, m, num_args - 1, args);
             return 0;
         }
     }
@@ -90,13 +130,13 @@ static int do_command(WINDOW *w, ToxWindow *self, Tox *m, int num_args, int num_
     return 1;
 }
 
-void execute(WINDOW* w, ToxWindow *self, Tox *m, char *cmd, int mode)
+void execute(WINDOW *w, ToxWindow *self, Tox *m, char *cmd, int mode)
 {
     if (string_is_empty(cmd))
         return;
 
     char args[MAX_NUM_ARGS][MAX_STR_SIZE] = {0};
-    int num_args = parse_command(w, cmd, args);
+    int num_args = parse_command(w, self, cmd, args);
 
     if (num_args == -1)
         return;
@@ -109,6 +149,7 @@ void execute(WINDOW* w, ToxWindow *self, Tox *m, char *cmd, int mode)
         case CHAT_COMMAND_MODE:
             if (do_command(w, self, m, num_args, CHAT_NUM_COMMANDS, chat_commands, args) == 0)
                 return;
+
             break;
 
         case GROUPCHAT_COMMAND_MODE:
@@ -118,5 +159,6 @@ void execute(WINDOW* w, ToxWindow *self, Tox *m, char *cmd, int mode)
     if (do_command(w, self, m, num_args, GLOBAL_NUM_COMMANDS, global_commands, args) == 0)
         return;
 
-    wprintw(w, "Invalid command.\n");
+    uint8_t *errmsg = "Invalid command.";
+    line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
 }

src/execute.h

@@ -1,10 +1,40 @@
-/*
- * Toxic -- Tox Curses Client
+/*  execute.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
+#ifndef _execute_h
+#define _execute_h
+
+#include "toxic.h"
+#include "windows.h"
+
 #define MAX_NUM_ARGS 4     /* Includes command */
-#define GLOBAL_NUM_COMMANDS 13
+
+#ifdef _SUPPORT_AUDIO
+#define GLOBAL_NUM_COMMANDS 16
+#define CHAT_NUM_COMMANDS 10
+#else
+#define GLOBAL_NUM_COMMANDS 14
 #define CHAT_NUM_COMMANDS 5
+#endif /* _SUPPORT_AUDIO */
 
 enum {
     GLOBAL_COMMAND_MODE,
@@ -13,3 +43,5 @@ enum {
 };
 
 void execute(WINDOW *w, ToxWindow *self, Tox *m, char *cmd, int mode);
+
+#endif /* #define _execute_h */

src/file_senders.c

@@ -0,0 +1,130 @@
+/*  file_senders.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "toxic.h"
+#include "windows.h"
+#include "file_senders.h"
+#include "line_info.h"
+
+FileSender file_senders[MAX_FILES];
+uint8_t max_file_senders_index;
+
+static void close_file_sender(int i)
+{
+    fclose(file_senders[i].file);
+    memset(&file_senders[i], 0, sizeof(FileSender));
+
+    int j;
+
+    for (j = max_file_senders_index; j > 0; --j) {
+        if (file_senders[j - 1].active)
+            break;
+    }
+
+    max_file_senders_index = j;
+}
+
+/* Should only be called on exit */
+void close_all_file_senders(void)
+{
+    int i;
+
+    for (i = 0; i < max_file_senders_index; ++i) {
+        if (file_senders[i].active)
+            fclose(file_senders[i].file);
+    }
+}
+
+void do_file_senders(Tox *m)
+{
+    uint8_t msg[MAX_STR_SIZE];
+    int i;
+
+    for (i = 0; i < max_file_senders_index; ++i) {
+        if (!file_senders[i].active)
+            continue;
+
+        ToxWindow *self = file_senders[i].toxwin;
+        uint8_t *pathname = file_senders[i].pathname;
+        int filenum = file_senders[i].filenum;
+        int32_t friendnum = file_senders[i].friendnum;
+        FILE *fp = file_senders[i].file;
+        uint64_t current_time = get_unix_time();
+
+        /* If file transfer has timed out kill transfer and send kill control */
+        if (timed_out(file_senders[i].timestamp, current_time, TIMEOUT_FILESENDER)) {
+            if (self->chatwin != NULL) {
+                snprintf(msg, sizeof(msg), "File transfer for '%s' timed out.", pathname);
+                line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+                alert_window(file_senders[i].toxwin, WINDOW_ALERT_2, true);
+            }
+
+            tox_file_send_control(m, friendnum, 0, filenum, TOX_FILECONTROL_KILL, 0, 0);
+            close_file_sender(i);
+            continue;
+        }
+
+        while (true) {
+            if (tox_file_send_data(m, friendnum, filenum, file_senders[i].nextpiece,
+                                   file_senders[i].piecelen) == -1)
+                break;
+
+            file_senders[i].timestamp = current_time;
+            file_senders[i].piecelen = fread(file_senders[i].nextpiece, 1,
+                                             tox_file_data_size(m, friendnum), fp);
+
+            /* refresh line with percentage complete */
+            if (self->chatwin != NULL) {
+                uint64_t size = file_senders[i].size;
+                long double remain = (long double) tox_file_data_remaining(m, friendnum, filenum, 0);
+                long double pct_remain = 100;
+
+                if (remain)
+                    pct_remain = (1 - (remain / size)) * 100;
+
+                const uint8_t *name = file_senders[i].pathname;
+                snprintf(msg, sizeof(msg), "File transfer for '%s' accepted (%.1Lf%%)", name, pct_remain);
+                line_info_set(self, file_senders[i].line_id, msg);
+            }
+
+            if (file_senders[i].piecelen == 0) {
+                if (self->chatwin != NULL) {
+                    snprintf(msg, sizeof(msg), "File '%s' successfuly sent.", pathname);
+                    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+                    alert_window(file_senders[i].toxwin, WINDOW_ALERT_2, true);
+                }
+
+                tox_file_send_control(m, friendnum, 0, filenum, TOX_FILECONTROL_FINISHED, 0, 0);
+                close_file_sender(i);
+                break;
+            }
+        }
+    }
+}

src/file_senders.h

@@ -0,0 +1,52 @@
+/*  file_senders.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _filesenders_h
+#define _filesenders_h
+
+#include "toxic.h"
+#include "windows.h"
+
+#define FILE_PIECE_SIZE 2048    /* must be >= (MAX_CRYPTO_DATA_SIZE - 2) in toxcore/net_crypto.h */
+#define MAX_FILES 256
+#define TIMEOUT_FILESENDER 300
+
+typedef struct {
+    FILE *file;
+    ToxWindow *toxwin;
+    int32_t friendnum;
+    bool active;
+    int filenum;
+    uint8_t nextpiece[FILE_PIECE_SIZE];
+    uint16_t piecelen;
+    uint8_t pathname[MAX_STR_SIZE];
+    uint64_t timestamp;
+    uint64_t size;
+    uint32_t line_id;
+} FileSender;
+
+/* Should only be called on exit */
+void close_all_file_senders(void);
+
+void do_file_senders(Tox *m);
+
+#endif  /* #define _filesenders_h */

src/friendlist.c

@@ -1,5 +1,23 @@
-/*
- * Toxic -- Tox Curses Client
+/*  friendlist.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
 #ifdef HAVE_CONFIG_H
@@ -9,12 +27,21 @@
 #include <string.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <time.h>
 
 #include <tox/tox.h>
 
+#include "toxic.h"
+#include "windows.h"
 #include "chat.h"
 #include "friendlist.h"
 #include "misc_tools.h"
+#include "line_info.h"
+#include "settings.h"
+
+#ifdef _SUPPORT_AUDIO
+#include "audio_call.h"
+#endif
 
 extern char *DATA_FILE;
 extern ToxWindow *prompt;
@@ -23,9 +50,17 @@ static int max_friends_index = 0;    /* marks the index of the last friend in fr
 static int num_selected = 0;
 static int num_friends = 0;
 
+extern struct _Winthread Winthread;
+extern struct user_settings *user_settings;
+
 ToxicFriend friends[MAX_FRIENDS_NUM];
 static int friendlist_index[MAX_FRIENDS_NUM] = {0};
 
+static struct _pendingDel {
+    int num;
+    bool active;
+} pendingdelete;
+
 #define S_WEIGHT 100
 
 static int index_name_cmp(const void *n1, const void *n2)
@@ -40,7 +75,7 @@ static int index_name_cmp(const void *n1, const void *n2)
 }
 
 /* sorts friendlist_index first by connection status then alphabetically */
-void sort_friendlist_index(Tox *m)
+void sort_friendlist_index(void)
 {
     int i;
     int n = 0;
@@ -53,52 +88,70 @@ void sort_friendlist_index(Tox *m)
     qsort(friendlist_index, num_friends, sizeof(int), index_name_cmp);
 }
 
-static void friendlist_onMessage(ToxWindow *self, Tox *m, int num, uint8_t *str, uint16_t len)
+static void update_friend_last_online(int32_t num, uint64_t timestamp)
+{
+    friends[num].last_online.last_on = timestamp;
+    friends[num].last_online.tm = *localtime(&timestamp);
+
+    /* if the format changes make sure TIME_STR_SIZE is the correct size */
+    const char *t = user_settings->time == TIME_12 ? "%I:%M %p" : "%H:%M";
+    strftime(friends[num].last_online.hour_min_str, TIME_STR_SIZE, t,
+             &friends[num].last_online.tm);
+}
+
+static void friendlist_onMessage(ToxWindow *self, Tox *m, int32_t num, uint8_t *str, uint16_t len)
 {
     if (num >= max_friends_index)
         return;
 
     if (friends[num].chatwin == -1) {
-        if (num_active_windows() < MAX_WINDOWS_NUM) {
+        if (get_num_active_windows() < MAX_WINDOWS_NUM) {
             friends[num].chatwin = add_window(m, new_chat(m, friends[num].num));
         } else {
+            str[len] = '\0';
+
             uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
-            tox_get_name(m, num, nick);
-            nick[TOXIC_MAX_NAME_LENGTH] = '\0';
-            wprintw(prompt->window, "%s: %s\n", nick, str);
+            int n_len = tox_get_name(m, num, nick);
+            n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
+            nick[n_len] = '\0';
 
-            prep_prompt_win();
-            wattron(prompt->window, COLOR_PAIR(RED));
-            wprintw(prompt->window, "* Warning: Too many windows are open.\n");
-            wattron(prompt->window, COLOR_PAIR(RED));
+            uint8_t timefrmt[TIME_STR_SIZE];
+            get_time_str(timefrmt);
 
+            line_info_add(prompt, timefrmt, nick, NULL, str, IN_MSG, 0, 0);
+
+            uint8_t *msg = "* Warning: Too many windows are open.";
+            line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, RED);
             alert_window(prompt, WINDOW_ALERT_1, true);
         }
     }
 }
 
-static void friendlist_onConnectionChange(ToxWindow *self, Tox *m, int num, uint8_t status)
+static void friendlist_onConnectionChange(ToxWindow *self, Tox *m, int32_t num, uint8_t status)
 {
     if (num >= max_friends_index)
         return;
 
-    friends[num].online = status == 1 ? true : false;
-    sort_friendlist_index(m);
+    friends[num].online = status;
+    update_friend_last_online(num, get_unix_time());
+    store_data(m, DATA_FILE);
+    sort_friendlist_index();
 }
 
-static void friendlist_onNickChange(ToxWindow *self, Tox *m, int num, uint8_t *str, uint16_t len)
+static void friendlist_onNickChange(ToxWindow *self, Tox *m, int32_t num, uint8_t *str, uint16_t len)
 {
     if (len > TOX_MAX_NAME_LENGTH || num >= max_friends_index)
         return;
 
-    str[TOXIC_MAX_NAME_LENGTH] = '\0';
-    len = strlen(str) + 1;
-    memcpy(friends[num].name, str, len);
+    len = MIN(len, TOXIC_MAX_NAME_LENGTH - 1);
+
+    str[len] = '\0';
+    strcpy(friends[num].name, str);
     friends[num].namelength = len;
-    sort_friendlist_index(m);
+    sort_friendlist_index();
 }
 
-static void friendlist_onStatusChange(ToxWindow *self, Tox *m, int num, TOX_USERSTATUS status)
+static void friendlist_onStatusChange(ToxWindow *self, Tox *m, int32_t num, uint8_t status)
 {
     if (num >= max_friends_index)
         return;
@@ -106,16 +159,19 @@ static void friendlist_onStatusChange(ToxWindow *self, Tox *m, int num, TOX_USER
     friends[num].status = status;
 }
 
-static void friendlist_onStatusMessageChange(ToxWindow *self, int num, uint8_t *str, uint16_t len)
+static void friendlist_onStatusMessageChange(ToxWindow *self, int32_t num, uint8_t *str, uint16_t len)
 {
     if (len > TOX_MAX_STATUSMESSAGE_LENGTH || num >= max_friends_index)
         return;
 
-    memcpy(friends[num].statusmsg, str, len);
+    str[len] = '\0';
+    snprintf(friends[num].statusmsg, sizeof(friends[num].statusmsg), "%s", str);
+    len = strlen(friends[num].statusmsg);
     friends[num].statusmsg_len = len;
+    friends[num].statusmsg[len] = '\0';
 }
 
-static void friendlist_onFriendAdded(ToxWindow *self, Tox *m, int num, bool sort)
+void friendlist_onFriendAdded(ToxWindow *self, Tox *m, int32_t num, bool sort)
 {
     if (max_friends_index < 0 || max_friends_index >= MAX_FRIENDS_NUM)
         return;
@@ -130,14 +186,16 @@ static void friendlist_onFriendAdded(ToxWindow *self, Tox *m, int num, bool sort
             friends[i].online = false;
             friends[i].status = TOX_USERSTATUS_NONE;
             friends[i].namelength = tox_get_name(m, num, friends[i].name);
+            friends[i].logging_on = (bool) user_settings->autolog == AUTOLOG_ON;
             tox_get_client_id(m, num, friends[i].pub_key);
+            update_friend_last_online(i, tox_get_last_online(m, i));
 
             if (friends[i].namelength == -1 || friends[i].name[0] == '\0') {
                 strcpy(friends[i].name, (uint8_t *) UNKNOWN_NAME);
-                friends[i].namelength = strlen(UNKNOWN_NAME) + 1;
+                friends[i].namelength = strlen(UNKNOWN_NAME);
             } else {    /* Enforce toxic's maximum name length */
-                friends[i].name[TOXIC_MAX_NAME_LENGTH] = '\0';
-                friends[i].namelength = strlen(friends[i].name) + 1;
+                friends[i].namelength = MIN(friends[i].namelength, TOXIC_MAX_NAME_LENGTH);
+                friends[i].name[friends[i].namelength] = '\0';
             }
 
             num_friends = tox_count_friendlist(m);
@@ -146,56 +204,56 @@ static void friendlist_onFriendAdded(ToxWindow *self, Tox *m, int num, bool sort
                 ++max_friends_index;
 
             if (sort)
-                sort_friendlist_index(m);
+                sort_friendlist_index();
 
             return;
         }
     }
 }
 
-static void friendlist_onFileSendRequest(ToxWindow *self, Tox *m, int num, uint8_t filenum, 
+static void friendlist_onFileSendRequest(ToxWindow *self, Tox *m, int32_t num, uint8_t filenum,
         uint64_t filesize, uint8_t *filename, uint16_t filename_len)
 {
     if (num >= max_friends_index)
         return;
 
     if (friends[num].chatwin == -1) {
-        if (num_active_windows() < MAX_WINDOWS_NUM) {
+        if (get_num_active_windows() < MAX_WINDOWS_NUM) {
             friends[num].chatwin = add_window(m, new_chat(m, friends[num].num));
         } else {
             tox_file_send_control(m, num, 1, filenum, TOX_FILECONTROL_KILL, 0, 0);
 
-            uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
-            tox_get_name(m, num, nick);
-            nick[TOXIC_MAX_NAME_LENGTH] = '\0';
+            uint8_t nick[TOX_MAX_NAME_LENGTH];
+            int n_len = tox_get_name(m, num, nick);
+            n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
+            nick[n_len] = '\0';
 
-            prep_prompt_win();
-            wattron(prompt->window, COLOR_PAIR(RED));
-            wprintw(prompt->window, "* File transfer from %s failed: too many windows are open.\n", nick);
-            wattron(prompt->window, COLOR_PAIR(RED));
+            uint8_t msg[MAX_STR_SIZE];
+            snprintf(msg, sizeof(msg), "* File transfer from %s failed: too many windows are open.", nick);
+            line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, RED);
 
             alert_window(prompt, WINDOW_ALERT_1, true);
         }
     }
 }
 
-static void friendlist_onGroupInvite(ToxWindow *self, Tox *m, int num, uint8_t *group_pub_key)
+static void friendlist_onGroupInvite(ToxWindow *self, Tox *m, int32_t num, uint8_t *group_pub_key)
 {
     if (num >= max_friends_index)
         return;
 
     if (friends[num].chatwin == -1) {
-        if (num_active_windows() < MAX_WINDOWS_NUM) {
+        if (get_num_active_windows() < MAX_WINDOWS_NUM) {
             friends[num].chatwin = add_window(m, new_chat(m, friends[num].num));
         } else {
-            uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
-            tox_get_name(m, num, nick);
-            nick[TOXIC_MAX_NAME_LENGTH] = '\0';
+            uint8_t nick[TOX_MAX_NAME_LENGTH];
+            int n_len = tox_get_name(m, num, nick);
+            n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
+            nick[n_len] = '\0';
 
-            prep_prompt_win();
-            wattron(prompt->window, COLOR_PAIR(RED));
-            wprintw(prompt->window, "* Group chat invite from %s failed: too many windows are open.\n", nick);
-            wattron(prompt->window, COLOR_PAIR(RED));
+            uint8_t msg[MAX_STR_SIZE];
+            snprintf(msg, sizeof(msg), "* Group chat invite from %s failed: too many windows are open.", nick);
+            line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, RED);
 
             alert_window(prompt, WINDOW_ALERT_1, true);
         }
@@ -212,7 +270,7 @@ static void select_friend(ToxWindow *self, Tox *m, wint_t key)
     }
 }
 
-static void delete_friend(Tox *m, ToxWindow *self, int f_num, wint_t key)
+static void delete_friend(Tox *m, int32_t f_num)
 {
     tox_del_friend(m, f_num);
     memset(&friends[f_num], 0, sizeof(ToxicFriend));
@@ -220,7 +278,7 @@ static void delete_friend(Tox *m, ToxWindow *self, int f_num, wint_t key)
     int i;
 
     for (i = max_friends_index; i > 0; --i) {
-        if (friends[i-1].active)
+        if (friends[i - 1].active)
             break;
     }
 
@@ -231,40 +289,91 @@ static void delete_friend(Tox *m, ToxWindow *self, int f_num, wint_t key)
     if (num_friends && num_selected == num_friends)
         --num_selected;
 
-    sort_friendlist_index(m);
+    sort_friendlist_index();
     store_data(m, DATA_FILE);
 }
 
-static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key)
+/* activates delete friend popup */
+static void del_friend_activate(ToxWindow *self, Tox *m, int32_t f_num)
+{
+    int x2, y2;
+    getmaxyx(self->window, y2, x2);
+    self->popup = newwin(3, 22 + TOXIC_MAX_NAME_LENGTH, 8, 8);
+
+    pendingdelete.active = true;
+    pendingdelete.num = f_num;
+}
+
+/* deactivates delete friend popup and deletes friend if instructed */
+static void del_friend_deactivate(ToxWindow *self, Tox *m, wint_t key)
+{
+    if (key == 'y')
+        delete_friend(m, pendingdelete.num);
+
+    memset(&pendingdelete, 0, sizeof(pendingdelete));
+    delwin(self->popup);
+    self->popup = NULL;
+    clear();
+    refresh();
+}
+
+static void draw_popup(ToxWindow *self, Tox *m)
+{
+    if (self->popup == NULL)
+        return;
+
+    wattron(self->popup, A_BOLD);
+    box(self->popup, ACS_VLINE, ACS_HLINE);
+    wattroff(self->popup, A_BOLD);
+
+    wmove(self->popup, 1, 1);
+    wprintw(self->popup, "Delete contact ");
+    wattron(self->popup, A_BOLD);
+    wprintw(self->popup, "%s", friends[pendingdelete.num].name);
+    wattroff(self->popup, A_BOLD);
+    wprintw(self->popup, "? y/n");
+
+    wrefresh(self->popup);
+}
+
+static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 {
     if (num_friends == 0)
         return;
 
     int f = friendlist_index[num_selected];
 
+    /* lock screen and force decision on deletion popup */
+    if (pendingdelete.active) {
+        if (key == 'y' || key == 'n')
+            del_friend_deactivate(self, m, key);
+
+        return;
+    }
+
+    if (key != ltr) {
         if (key == '\n') {
             /* Jump to chat window if already open */
             if (friends[f].chatwin != -1) {
                 set_active_window(friends[f].chatwin);
-        } else if (num_active_windows() < MAX_WINDOWS_NUM) {
+            } else if (get_num_active_windows() < MAX_WINDOWS_NUM) {
                 friends[f].chatwin = add_window(m, new_chat(m, friends[f].num));
                 set_active_window(friends[f].chatwin);
             } else {
-            prep_prompt_win();
-            wattron(prompt->window, COLOR_PAIR(RED));
-            wprintw(prompt->window, "* Warning: Too many windows are open.\n");
-            wattron(prompt->window, COLOR_PAIR(RED));
+                uint8_t *msg = "* Warning: Too many windows are open.";
+                line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, RED);
 
                 alert_window(prompt, WINDOW_ALERT_1, true);
             }
         } else if (key == KEY_DC) {
-        delete_friend(m, self, f, key);
+            del_friend_activate(self, m, f);
         } else {
             select_friend(self, m, key);
         }
+    }
 }
 
-#define FLIST_OFST 4    /* Accounts for the lines at top */
+#define FLIST_OFST 6    /* Accounts for space at top and bottom */
 
 static void friendlist_onDraw(ToxWindow *self, Tox *m)
 {
@@ -273,6 +382,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
+    uint64_t cur_time = get_unix_time();
+    struct tm cur_loc_tm = *localtime(&cur_time);
+
     bool fix_statuses = x2 != self->x;    /* true if window x axis has changed */
 
     wattron(self->window, COLOR_PAIR(CYAN));
@@ -287,13 +399,20 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
     wprintw(self->window, "key.\n\n");
     wattroff(self->window, COLOR_PAIR(CYAN));
 
+    pthread_mutex_lock(&Winthread.lock);
+    int nf = tox_get_num_online_friends(m);
+    pthread_mutex_unlock(&Winthread.lock);
+
     wattron(self->window, A_BOLD);
-    wprintw(self->window, " Friends: %d/%d \n\n", tox_get_num_online_friends(m), num_friends);
+    wprintw(self->window, " Online: ");
     wattroff(self->window, A_BOLD);
+    wprintw(self->window, "%d/%d \n\n", nf, num_friends);
 
     if ((y2 - FLIST_OFST) <= 0)    /* don't allow division by zero */
         return;
 
+    int selected_num = 0;
+
     /* Determine which portion of friendlist to draw based on current position */
     int page = num_selected / (y2 - FLIST_OFST);
     int start = (y2 - FLIST_OFST) * page;
@@ -310,90 +429,171 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                 wattron(self->window, A_BOLD);
                 wprintw(self->window, " > ");
                 wattroff(self->window, A_BOLD);
+                selected_num = f;
                 f_selected = true;
             } else {
                 wprintw(self->window, "   ");
             }
 
             if (friends[f].online) {
-                TOX_USERSTATUS status = friends[f].status;
+                uint8_t status = friends[f].status;
                 int colour = WHITE;
 
                 switch (status) {
                     case TOX_USERSTATUS_NONE:
                         colour = GREEN;
                         break;
+
                     case TOX_USERSTATUS_AWAY:
                         colour = YELLOW;
                         break;
+
                     case TOX_USERSTATUS_BUSY:
                         colour = RED;
                         break;
+
+                    case TOX_USERSTATUS_INVALID:
+                        colour = MAGENTA;
+                        break;
                 }
 
-                wprintw(self->window, "[");
                 wattron(self->window, COLOR_PAIR(colour) | A_BOLD);
-                wprintw(self->window, "O");
+                wprintw(self->window, "O ");
                 wattroff(self->window, COLOR_PAIR(colour) | A_BOLD);
-                wprintw(self->window, "]");
 
                 if (f_selected)
+                    wattron(self->window, COLOR_PAIR(BLUE));
+
                 wattron(self->window, A_BOLD);
-
                 wprintw(self->window, "%s", friends[f].name);
+                wattroff(self->window, A_BOLD);
 
                 if (f_selected)
-                    wattroff(self->window, A_BOLD);
+                    wattroff(self->window, COLOR_PAIR(BLUE));
 
                 /* Reset friends[f].statusmsg on window resize */
                 if (fix_statuses) {
                     uint8_t statusmsg[TOX_MAX_STATUSMESSAGE_LENGTH] = {'\0'};
-                    tox_get_status_message(m, friends[f].num, statusmsg, TOX_MAX_STATUSMESSAGE_LENGTH);
+
+                    pthread_mutex_lock(&Winthread.lock);
+                    uint16_t s_len = tox_get_status_message(m, friends[f].num, statusmsg,
+                                                            TOX_MAX_STATUSMESSAGE_LENGTH);
+                    pthread_mutex_unlock(&Winthread.lock);
+
+                    friends[f].statusmsg_len = s_len;
+                    friends[f].statusmsg[s_len] = '\0';
                     snprintf(friends[f].statusmsg, sizeof(friends[f].statusmsg), "%s", statusmsg);
-                    friends[f].statusmsg_len = tox_get_status_message_size(m, f);
                 }
 
                 /* Truncate note if it doesn't fit on one line */
-                uint16_t maxlen = x2 - getcurx(self->window) - 4;
+                uint16_t maxlen = x2 - getcurx(self->window) - 2;
+
                 if (friends[f].statusmsg_len > maxlen) {
-                    friends[f].statusmsg[maxlen-3] = '\0';
+                    friends[f].statusmsg[maxlen - 3] = '\0';
                     strcat(friends[f].statusmsg, "...");
                     friends[f].statusmsg[maxlen] = '\0';
                     friends[f].statusmsg_len = maxlen;
                 }
 
-                wprintw(self->window, " (%s)\n", friends[f].statusmsg);
+                if (friends[f].statusmsg[0])
+                    wprintw(self->window, " %s", friends[f].statusmsg);
+
+                wprintw(self->window, "\n");
             } else {
-                wprintw(self->window, "[");
-                wattron(self->window, A_BOLD);
-                wprintw(self->window, "O");
-                wattroff(self->window, A_BOLD);
-                wprintw(self->window, "]");
+                wprintw(self->window, "o ");
 
                 if (f_selected)
-                    wattron(self->window, A_BOLD);
+                    wattron(self->window, COLOR_PAIR(BLUE));
 
-                wprintw(self->window, "%s\n", friends[f].name);
+                wattron(self->window, A_BOLD);
+                wprintw(self->window, "%s", friends[f].name);
+                wattroff(self->window, A_BOLD);
 
                 if (f_selected)
-                    wattroff(self->window, A_BOLD);
+                    wattroff(self->window, COLOR_PAIR(BLUE));
+
+                uint64_t last_seen = friends[f].last_online.last_on;
+
+                if (last_seen != 0) {
+                    int day_dist = (cur_loc_tm.tm_yday - friends[f].last_online.tm.tm_yday) % 365;
+                    const uint8_t *hourmin = friends[f].last_online.hour_min_str;
+
+                    switch (day_dist) {
+                        case 0:
+                            wprintw(self->window, " Last seen: Today %s\n", hourmin);
+                            break;
+
+                        case 1:
+                            wprintw(self->window, " Last seen: Yesterday %s\n", hourmin);
+                            break;
+
+                        default:
+                            wprintw(self->window, " Last seen: %d days ago\n", day_dist);
+                            break;
+                    }
+                } else {
+                    wprintw(self->window, " Last seen: Never\n");
+                }
             }
         }
     }
 
     self->x = x2;
     wrefresh(self->window);
+    draw_popup(self, m);
+
+    if (num_friends) {
+        wmove(self->window, y2 - 1, 1);
+
+        wattron(self->window, A_BOLD);
+        wprintw(self->window, "ID: ");
+        wattroff(self->window, A_BOLD);
+
+        int i;
+
+        for (i = 0; i < TOX_CLIENT_ID_SIZE; ++i)
+            wprintw(self->window, "%02X", friends[selected_num].pub_key[i] & 0xff);
+    }
 }
 
-void disable_chatwin(int f_num)
+void disable_chatwin(int32_t f_num)
 {
     friends[f_num].chatwin = -1;
 }
 
-static void friendlist_onInit(ToxWindow *self, Tox *m)
+#ifdef _SUPPORT_AUDIO
+static void friendlist_onAv(ToxWindow *self, ToxAv *av, int call_index)
 {
+    int id = toxav_get_peer_id(av, call_index, 0);
 
+    /*id++;*/
+    if ( id != ErrorInternal && id >= max_friends_index)
+        return;
+
+    Tox *m = toxav_get_tox(av);
+
+    if (friends[id].chatwin == -1) {
+        if (get_num_active_windows() < MAX_WINDOWS_NUM) {
+            friends[id].chatwin = add_window(m, new_chat(m, friends[id].num));
+        } else {
+            uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
+            int n_len = tox_get_name(m, id, nick);
+
+            n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
+            nick[n_len] = '\0';
+
+            uint8_t msg[MAX_STR_SIZE];
+            snprintf(msg, sizeof(msg), "Audio action from: %s!", nick);
+            line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+
+            uint8_t *errmsg = "* Warning: Too many windows are open.";
+            line_info_add(prompt, NULL, NULL, NULL, errmsg, SYS_MSG, 0, RED);
+
+            alert_window(prompt, WINDOW_ALERT_0, true);
+        }
+    }
 }
+#endif /* _SUPPORT_AUDIO */
 
 ToxWindow new_friendlist(void)
 {
@@ -404,17 +604,32 @@ ToxWindow new_friendlist(void)
 
     ret.onKey = &friendlist_onKey;
     ret.onDraw = &friendlist_onDraw;
-    ret.onInit = &friendlist_onInit;
     ret.onFriendAdded = &friendlist_onFriendAdded;
     ret.onMessage = &friendlist_onMessage;
     ret.onConnectionChange = &friendlist_onConnectionChange;
-    ret.onAction = &friendlist_onMessage;    // Action has identical behaviour to message
+    ret.onAction = &friendlist_onMessage;    /* Action has identical behaviour to message */
     ret.onNickChange = &friendlist_onNickChange;
     ret.onStatusChange = &friendlist_onStatusChange;
     ret.onStatusMessageChange = &friendlist_onStatusMessageChange;
     ret.onFileSendRequest = &friendlist_onFileSendRequest;
     ret.onGroupInvite = &friendlist_onGroupInvite;
 
+#ifdef _SUPPORT_AUDIO
+    ret.onInvite = &friendlist_onAv;
+    ret.onRinging = &friendlist_onAv;
+    ret.onStarting = &friendlist_onAv;
+    ret.onEnding = &friendlist_onAv;
+    ret.onError = &friendlist_onAv;
+    ret.onStart = &friendlist_onAv;
+    ret.onCancel = &friendlist_onAv;
+    ret.onReject = &friendlist_onAv;
+    ret.onEnd = &friendlist_onAv;
+    ret.onRequestTimeout = &friendlist_onAv;
+    ret.onPeerTimeout = &friendlist_onAv;
+    
+    ret.call_index = -1;
+#endif /* _SUPPORT_AUDIO */
+
     strcpy(ret.name, "friends");
     return ret;
 }

src/friendlist.h

@@ -1,7 +1,49 @@
+/*  friendlist.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
 #ifndef FRIENDLIST_H_53I41IM
 #define FRIENDLIST_H_53I41IM
 
-#include "toxic_windows.h"
+#include <time.h>
+
+#include "toxic.h"
+#include "windows.h"
+#include "file_senders.h"
+
+#define TIME_STR_SIZE 16
+
+struct FileReceiver {
+    uint8_t filenames[MAX_FILES][MAX_STR_SIZE];
+    FILE *files[MAX_FILES];
+    bool pending[MAX_FILES];
+    uint64_t size[MAX_FILES];
+    uint32_t line_id[MAX_FILES];
+};
+
+struct LastOnline {
+    uint64_t last_on;
+    struct tm tm;
+    uint8_t hour_min_str[TIME_STR_SIZE];    /* holds 12-hour time string e.g. "10:43 PM" */
+};
 
 typedef struct {
     uint8_t name[TOX_MAX_NAME_LENGTH];
@@ -10,19 +52,24 @@ typedef struct {
     uint16_t statusmsg_len;
     uint8_t pending_groupchat[TOX_CLIENT_ID_SIZE];
     uint8_t pub_key[TOX_CLIENT_ID_SIZE];
-    int num;
+    int32_t num;
     int chatwin;
     bool active;
     bool online;
-    TOX_USERSTATUS status;
+    uint8_t is_typing;
+    bool logging_on;    /* saves preference for friend irrespective of chat windows */
+    uint8_t status;
+    struct LastOnline last_online;
     struct FileReceiver file_receiver;
 } ToxicFriend;
 
 ToxWindow new_friendlist(void);
-void disable_chatwin(int f_num);
+void disable_chatwin(int32_t f_num);
 int get_friendnum(uint8_t *name);
 
+void friendlist_onFriendAdded(ToxWindow *self, Tox *m, int32_t num, bool sort);
+
 /* sorts friendlist_index first by connection status then alphabetically */
-void sort_friendlist_index(Tox *m);
+void sort_friendlist_index(void);
 
 #endif /* end of include guard: FRIENDLIST_H_53I41IM */

src/global_commands.c

@@ -1,5 +1,23 @@
-/*
- * Toxic -- Tox Curses Client
+/*  global_commands.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
 #ifdef HAVE_CONFIG_H
@@ -9,9 +27,13 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "toxic_windows.h"
+#include "toxic.h"
+#include "windows.h"
 #include "misc_tools.h"
 #include "friendlist.h"
+#include "log.h"
+#include "line_info.h"
+#include "dns.h"
 
 extern char *DATA_FILE;
 extern ToxWindow *prompt;
@@ -24,30 +46,34 @@ extern uint8_t num_frnd_requests;
 /* command functions */
 void cmd_accept(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    /* check arguments */
+    uint8_t *msg;
+
     if (argc != 1) {
-      wprintw(window, "Invalid syntax.\n");
+        msg = "Invalid syntax.";
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
         return;
     }
 
     int req = atoi(argv[1]);
 
-    if ((req == 0 && strcmp(argv[1], "0"))|| req >= MAX_FRIENDS_NUM) {
-        wprintw(window, "No pending friend request with that number.\n");
+    if ((req == 0 && strcmp(argv[1], "0")) || req >= MAX_FRIENDS_NUM) {
+        msg = "No pending friend request with that number.";
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
         return;
     }
 
     if (!strlen(pending_frnd_requests[req])) {
-        wprintw(window, "No pending friend request with that number.\n");
+        msg = "No pending friend request with that number.";
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
         return;
     }
 
-    int friendnum = tox_add_friend_norequest(m, pending_frnd_requests[req]);
+    int32_t friendnum = tox_add_friend_norequest(m, pending_frnd_requests[req]);
 
     if (friendnum == -1)
-        wprintw(window, "Failed to add friend.\n");
+        msg = "Failed to add friend.";
     else {
-        wprintw(window, "Friend request accepted.\n");
+        msg = "Friend request accepted.";
         on_friendadded(m, friendnum, true);
     }
 
@@ -56,17 +82,64 @@ void cmd_accept(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     int i;
 
     for (i = num_frnd_requests; i > 0; --i) {
-        if (!strlen(pending_frnd_requests[i-1]))
+        if (!strlen(pending_frnd_requests[i - 1]))
             break;
     }
 
     num_frnd_requests = i;
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+}
+
+void cmd_add_helper(ToxWindow *self, Tox *m, uint8_t *id_bin, uint8_t *msg)
+{
+    uint8_t *errmsg;
+    int32_t f_num = tox_add_friend(m, id_bin, msg, strlen(msg));
+
+    switch (f_num) {
+        case TOX_FAERR_TOOLONG:
+            errmsg = "Message is too long.";
+            break;
+
+        case TOX_FAERR_NOMESSAGE:
+            errmsg = "Please add a message to your request.";
+            break;
+
+        case TOX_FAERR_OWNKEY:
+            errmsg = "That appears to be your own ID.";
+            break;
+
+        case TOX_FAERR_ALREADYSENT:
+            errmsg = "Friend request has already been sent.";
+            break;
+
+        case TOX_FAERR_UNKNOWN:
+            errmsg = "Undefined error when adding friend.";
+            break;
+
+        case TOX_FAERR_BADCHECKSUM:
+            errmsg = "Bad checksum in address.";
+            break;
+
+        case TOX_FAERR_SETNEWNOSPAM:
+            errmsg = "Nospam was different.";
+            break;
+
+        default:
+            errmsg = "Friend request sent.";
+            on_friendadded(m, f_num, true);
+            break;
+    }
+
+    line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
 }
 
 void cmd_add(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    uint8_t *errmsg;
+
     if (argc < 1) {
-        wprintw(window, "Invalid syntax.\n");
+        errmsg = "Invalid syntax.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
@@ -77,27 +150,28 @@ void cmd_add(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
         uint8_t *temp = argv[2];
 
         if (temp[0] != '\"') {
-            wprintw(window, "Message must be enclosed in quotes.\n");
+            errmsg = "Message must be enclosed in quotes.";
+            line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
             return;
         }
 
-        temp[strlen(++temp)-1] = L'\0';
+        temp[strlen(++temp) - 1] = L'\0';
         snprintf(msg, sizeof(msg), "%s", temp);
     } else {
         uint8_t selfname[TOX_MAX_NAME_LENGTH];
-        tox_get_self_name(m, selfname, TOX_MAX_NAME_LENGTH);
+        uint16_t n_len = tox_get_self_name(m, selfname);
+        selfname[n_len] = '\0';
         snprintf(msg, sizeof(msg), "Hello, my name is %s. Care to Tox?", selfname);
     }
 
-    if (strlen(id) != 2 * TOX_FRIEND_ADDRESS_SIZE) {
-        wprintw(window, "Invalid ID length.\n");
-        return;
-    }
+    uint8_t id_bin[TOX_FRIEND_ADDRESS_SIZE] = {0};
+    uint16_t id_len = strlen(id);
 
+    /* try to add tox ID */
+    if (id_len == 2 * TOX_FRIEND_ADDRESS_SIZE) {
         size_t i;
         char xx[3];
         uint32_t x;
-    uint8_t id_bin[TOX_FRIEND_ADDRESS_SIZE];
 
         for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; ++i) {
             xx[0] = id[2 * i];
@@ -105,69 +179,50 @@ void cmd_add(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
             xx[2] = '\0';
 
             if (sscanf(xx, "%02x", &x) != 1) {
-            wprintw(window, "Invalid ID.\n");
+                errmsg = "Invalid ID.";
+                line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
                 return;
             }
 
             id_bin[i] = x;
         }
 
-    for (i = 0; i < TOX_FRIEND_ADDRESS_SIZE; i++) {
-        id[i] = toupper(id[i]);
-    }
-
-    int f_num = tox_add_friend(m, id_bin, msg, strlen(msg) + 1);
-
-    switch (f_num) {
-    case TOX_FAERR_TOOLONG:
-        wprintw(window, "Message is too long.\n");
-        break;
-    case TOX_FAERR_NOMESSAGE:
-        wprintw(window, "Please add a message to your request.\n");
-        break;
-    case TOX_FAERR_OWNKEY:
-        wprintw(window, "That appears to be your own ID.\n");
-        break;
-    case TOX_FAERR_ALREADYSENT:
-        wprintw(window, "Friend request has already been sent.\n");
-        break;
-    case TOX_FAERR_UNKNOWN:
-        wprintw(window, "Undefined error when adding friend.\n");
-        break;
-    case TOX_FAERR_BADCHECKSUM:
-        wprintw(window, "Bad checksum in address.\n");
-        break;
-    case TOX_FAERR_SETNEWNOSPAM:
-        wprintw(window, "Nospam was different (is this contact already added?)\n");
-        break;
-    default:
-        wprintw(window, "Friend request sent.\n");
-        on_friendadded(m, f_num, true);
-        break;
+        cmd_add_helper(self, m, id_bin, msg);
+    } else {    /* assume id is a username@domain address and do DNS lookup */
+        dns3_lookup(self, m, id_bin, id, msg);
     }
 }
 
 void cmd_clear(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    line_info_clear(self->chatwin->hst);
     wclear(window);
-    wprintw(window, "\n\n");
+
+    if (self->is_prompt) {
+        int y2, x2;
+        getmaxyx(window, y2, x2);
+        wmove(self->chatwin->history, y2 - 1, 2);
+    }
 }
 
 void cmd_connect(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    uint8_t *errmsg;
+
     /* check arguments */
     if (argc != 3) {
-      wprintw(window, "Invalid syntax.\n");
+        errmsg = "Invalid syntax.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
-    tox_IP_Port dht;
     char *ip = argv[1];
     char *port = argv[2];
     char *key = argv[3];
 
     if (atoi(port) == 0) {
-        wprintw(window, "Invalid syntax.\n");
+        errmsg = "Invalid syntax.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
@@ -179,27 +234,80 @@ void cmd_connect(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
 
 void cmd_groupchat(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    if (num_active_windows() >= MAX_WINDOWS_NUM) {
-        wattron(window, COLOR_PAIR(RED));
-        wprintw(window, " * Warning: Too many windows are open.\n");
-        wattron(window, COLOR_PAIR(RED));
+    uint8_t *errmsg;
+
+    if (get_num_active_windows() >= MAX_WINDOWS_NUM) {
+        errmsg = " * Warning: Too many windows are open.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, RED);
         return;
     }
 
     int groupnum = tox_add_groupchat(m);
 
     if (groupnum == -1) {
-        wprintw(window, "Group chat instance failed to initialize.\n");
+        errmsg = "Group chat instance failed to initialize.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     if (init_groupchat_win(prompt, m, groupnum) == -1) {
-        wprintw(window, "Group chat window failed to initialize.\n");
+        errmsg = "Group chat window failed to initialize.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         tox_del_groupchat(m, groupnum);
         return;
     }
 
-    wprintw(window, "Group chat created as %d.\n", groupnum);
+    uint8_t msg[MAX_STR_SIZE];
+    snprintf(msg, sizeof(msg), "Group chat created as %d.", groupnum);
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+}
+
+void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    uint8_t *msg;
+    struct chatlog *log = self->chatwin->log;
+
+    if (argc == 0) {
+        if (log->log_on)
+            msg = "Logging for this window is ON. Type \"/log off\" to disable.";
+        else
+            msg = "Logging for this window is OFF. Type \"/log on\" to enable.";
+
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        return;
+    }
+
+    uint8_t *swch = argv[1];
+
+    if (!strcmp(swch, "1") || !strcmp(swch, "on")) {
+
+        if (self->is_chat) {
+            friends[self->num].logging_on = true;
+            log_enable(self->name, friends[self->num].pub_key, log);
+        } else if (self->is_prompt) {
+            uint8_t myid[TOX_FRIEND_ADDRESS_SIZE];
+            tox_get_address(m, myid);
+            log_enable(self->name, myid, log);
+        } else if (self->is_groupchat) {
+            log_enable(self->name, NULL, log);
+        }
+
+        msg = "Logging enabled";
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        return;
+    } else if (!strcmp(swch, "0") || !strcmp(swch, "off")) {
+        if (self->is_chat)
+            friends[self->num].logging_on = false;
+
+        log_disable(log);
+
+        msg = "Logging disabled";
+        line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+        return;
+    }
+
+    msg = "Invalid option. Use \"/log on\" and \"/log off\" to toggle logging.";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
 }
 
 void cmd_myid(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@@ -216,14 +324,17 @@ void cmd_myid(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
         strcat(id, xx);
     }
 
-    wprintw(window, "%s\n", id);
+    line_info_add(self, NULL, NULL, NULL, id, SYS_MSG, 0, 0);
 }
 
 void cmd_nick(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    uint8_t *errmsg;
+
     /* check arguments */
     if (argc < 1) {
-      wprintw(window, "Invalid name.\n");
+        errmsg = "Invalid name.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
@@ -237,106 +348,133 @@ void cmd_nick(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
     }
 
     if (!valid_nick(nick)) {
-        wprintw(window, "Invalid name.\n");
+        errmsg = "Invalid name.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
-    if (len > TOXIC_MAX_NAME_LENGTH) {
-        nick[TOXIC_MAX_NAME_LENGTH] = L'\0';
-        len = TOXIC_MAX_NAME_LENGTH;
-    }
+    len = MIN(len, TOXIC_MAX_NAME_LENGTH - 1);
 
-    tox_set_name(m, nick, len+1);
-    prompt_update_nick(prompt, nick, len+1);
+    nick[len] = L'\0';
+
+    tox_set_name(m, nick, len);
+    prompt_update_nick(prompt, nick, len);
 
     store_data(m, DATA_FILE);
 }
 
 void cmd_note(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    uint8_t *errmsg;
+
     if (argc < 1) {
-        wprintw(window, "Wrong number of arguments.\n");
+        errmsg = "Wrong number of arguments.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     uint8_t *msg = argv[1];
 
     if (msg[0] != '\"') {
-        wprintw(window, "Note must be enclosed in quotes.\n");
+        errmsg = "Note must be enclosed in quotes.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
-    msg[strlen(++msg)-1] = L'\0';
-    uint16_t len = strlen(msg) + 1;
+    msg[strlen(++msg) - 1] = L'\0';
+    uint16_t len = strlen(msg);
     tox_set_status_message(m, msg, len);
-
     prompt_update_statusmessage(prompt, msg, len);
 }
 
 void cmd_prompt_help(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    wclear(window);
-    wattron(window, COLOR_PAIR(CYAN) | A_BOLD);
-    wprintw(window, "\n\nGlobal commands:\n");
-    wattroff(window, COLOR_PAIR(CYAN) | A_BOLD);
+    struct history *hst = self->chatwin->hst;
+    line_info_clear(hst);
+    struct line_info *start = hst->line_start;
 
-    wprintw(window, "      /add <id> <msg>            : Add friend with optional message\n");
-    wprintw(window, "      /accept <n>                : Accept friend request\n");
-    wprintw(window, "      /connect <ip> <port> <key> : Manually connect to a DHT server\n");
-    wprintw(window, "      /status <type> <msg>       : Set your status with optional note\n");
-    wprintw(window, "      /note <msg>                : Set a personal note\n");
-    wprintw(window, "      /nick <nick>               : Set your nickname\n");
-    wprintw(window, "      /groupchat                 : Create a group chat\n");
-    wprintw(window, "      /myid                      : Print your ID\n");
-    wprintw(window, "      /quit or /exit             : Exit Toxic\n");
-    wprintw(window, "      /help                      : Print this message again\n");
-    wprintw(window, "      /clear                     : Clear the window\n");
+    uint8_t *msg = "Global commands:";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
 
-    wattron(window, COLOR_PAIR(CYAN) | A_BOLD);
-    wprintw(window, " * Argument messages must be enclosed in quotation marks.\n");
-    wprintw(window, " * Use ctrl-o and ctrl-p to navigate through the tabs.\n\n");
-    wattroff(window, COLOR_PAIR(CYAN) | A_BOLD);
+#ifdef _SUPPORT_AUDIO
+#define NUMLINES 14
+#else
+#define NUMLINES 12
+#endif
+
+    uint8_t lines[NUMLINES][MAX_STR_SIZE] = {
+
+        { "    /add <id> <msg>            : Add friend with optional message"               },
+        { "    /accept <n>                : Accept friend request"                          },
+        { "    /connect <ip> <port> <key> : Manually connect to a DHT node"                 },
+        { "    /status <type> <msg>       : Set status with optional note"                  },
+        { "    /note <msg>                : Set a personal note"                            },
+        { "    /nick <nick>               : Set your nickname"                              },
+        { "    /log <on> or <off>         : Enable/disable logging"                         },
+        { "    /groupchat                 : Create a group chat"                            },
+        { "    /myid                      : Print your ID"                                  },
+        { "    /help                      : Print this message again"                       },
+        { "    /clear                     : Clear window history"                           },
+        { "    /quit or /exit             : Exit Toxic"                                     },
+#ifdef _SUPPORT_AUDIO
+        { "    /lsdev <type>              : List devices where type: in|out"                },
+        { "    /sdev <type> <id>          : Set active device"                              },
+#endif /* _SUPPORT_AUDIO */
+
+    };
+    int i;
+
+    for (i = 0; i < NUMLINES; ++i)
+        line_info_add(self, NULL, NULL, NULL, lines[i], SYS_MSG, 0, 0);
+
+    msg = " * Argument messages must be enclosed in quotation marks.";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
+    msg = " * Use ctrl-o and ctrl-p to navigate through the tabs.";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
+    line_info_add(self, NULL, NULL, NULL, "", SYS_MSG, 0, 0);
+
+    hst->line_start = start;
 }
 
 void cmd_quit(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    exit_toxic(m);
+    exit_toxic_success(m);
 }
 
 void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     uint8_t *msg = NULL;
+    uint8_t *errmsg;
 
     if (argc >= 2) {
         msg = argv[2];
 
         if (msg[0] != '\"') {
-            wprintw(window, "Note must be enclosed in quotes.\n");
+            errmsg = "Note must be enclosed in quotes.";
+            line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
             return;
         }
     } else if (argc != 1) {
-        wprintw(window, "Wrong number of arguments.\n");
+        errmsg = "Wrong number of arguments.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
     char *status = argv[1];
+    str_to_lower(status);
     int len = strlen(status);
-    char l_status[len+1];
-    int i;
-
-    for (i = 0; i <= len; ++i)
-        l_status[i] = tolower(status[i]);
 
     TOX_USERSTATUS status_kind;
 
-    if (!strcmp(l_status, "online"))
+    if (!strcmp(status, "online"))
         status_kind = TOX_USERSTATUS_NONE;
-    else if (!strcmp(l_status, "away"))
+    else if (!strcmp(status, "away"))
         status_kind = TOX_USERSTATUS_AWAY;
-    else if (!strcmp(l_status, "busy"))
+    else if (!strcmp(status, "busy"))
         status_kind = TOX_USERSTATUS_BUSY;
     else {
-        wprintw(window, "Invalid status. Valid statuses are: online, busy and away.\n");
+        errmsg = "Invalid status. Valid statuses are: online, busy and away.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
         return;
     }
 
@@ -344,8 +482,8 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
     prompt_update_status(prompt, status_kind);
 
     if (msg != NULL) {
-        msg[strlen(++msg)-1] = L'\0';   /* remove opening and closing quotes */
-        uint16_t len = strlen(msg) + 1;
+        msg[strlen(++msg) - 1] = L'\0'; /* remove opening and closing quotes */
+        uint16_t len = strlen(msg);
         tox_set_status_message(m, msg, len);
         prompt_update_statusmessage(prompt, msg, len);
     }

src/global_commands.h

@@ -1,15 +1,49 @@
-/*
- * Toxic -- Tox Curses Client
+/*  global_commands.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
+#ifndef _global_commands_h
+#define _global_commands_h
+
+#include "windows.h"
+#include "toxic.h"
+
 void cmd_accept(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_add(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_clear(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_connect(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_groupchat(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_log(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_myid(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_nick(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_note(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_prompt_help(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_quit(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_status(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+
+void cmd_add_helper(ToxWindow *self, Tox *m, uint8_t *id_bin, uint8_t *msg);
+
+#ifdef _SUPPORT_AUDIO
+void cmd_list_devices(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_change_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+#endif /* _SUPPORT_AUDIO */
+
+#endif /* #define _global_commands_h */

src/groupchat.c

@@ -1,5 +1,23 @@
-/*
- * Toxic -- Tox Curses Client
+/*  groupchat.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
 #ifdef HAVE_CONFIG_H
@@ -10,24 +28,33 @@
 #include <string.h>
 #include <time.h>
 
-#include "toxic_windows.h"
+#include "windows.h"
+#include "toxic.h"
 #include "execute.h"
 #include "misc_tools.h"
 #include "groupchat.h"
 #include "prompt.h"
 #include "toxic_strings.h"
+#include "log.h"
+#include "line_info.h"
+#include "settings.h"
 
 extern char *DATA_FILE;
 extern int store_data(Tox *m, char *path);
 
-static GroupChat groupchats[MAX_WINDOWS_NUM];
+static GroupChat groupchats[MAX_GROUPCHAT_NUM];
 static int max_groupchat_index = 0;
 
+extern struct user_settings *user_settings;
+
 /* temporary until group chats have unique commands */
-extern glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE];
+extern const uint8_t glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE];
 
 int init_groupchat_win(ToxWindow *prompt, Tox *m, int groupnum)
 {
+    if (groupnum > MAX_GROUPCHAT_NUM)
+        return -1;
+
     int i;
 
     for (i = 0; i <= max_groupchat_index; ++i) {
@@ -37,9 +64,14 @@ int init_groupchat_win(ToxWindow *prompt, Tox *m, int groupnum)
             groupchats[i].num_peers = 0;
             groupchats[i].peer_names = malloc(sizeof(uint8_t) * TOX_MAX_NAME_LENGTH);
             groupchats[i].oldpeer_names = malloc(sizeof(uint8_t) * TOX_MAX_NAME_LENGTH);
+            groupchats[i].peer_name_lengths = malloc(sizeof(uint16_t));
+            groupchats[i].oldpeer_name_lengths = malloc(sizeof(uint16_t));
+
+            memset(groupchats[i].peer_names, 0, sizeof(uint8_t) * TOX_MAX_NAME_LENGTH);
+            memset(groupchats[i].peer_name_lengths, 0, sizeof(uint16_t));
 
-            /* temp fix */
             memcpy(&groupchats[i].oldpeer_names[0], UNKNOWN_NAME, sizeof(UNKNOWN_NAME));
+            groupchats[i].oldpeer_name_lengths[0] = (uint16_t) strlen(UNKNOWN_NAME);
 
             set_active_window(groupchats[i].chatwin);
 
@@ -53,45 +85,80 @@ int init_groupchat_win(ToxWindow *prompt, Tox *m, int groupnum)
     return -1;
 }
 
-static void close_groupchatwin(Tox *m, int groupnum)
+void kill_groupchat_window(ToxWindow *self)
 {
+    ChatContext *ctx = self->chatwin;
+
+    log_disable(ctx->log);
+    line_info_cleanup(ctx->hst);
+    delwin(ctx->linewin);
+    del_window(self);
+    free(ctx->log);
+    free(ctx->hst);
+    free(ctx);
+}
+
+static void close_groupchat(ToxWindow *self, Tox *m, int groupnum)
+{
+    set_active_window(0);
     tox_del_groupchat(m, groupnum);
 
     free(groupchats[groupnum].peer_names);
     free(groupchats[groupnum].oldpeer_names);
+    free(groupchats[groupnum].peer_name_lengths);
+    free(groupchats[groupnum].oldpeer_name_lengths);
     memset(&groupchats[groupnum], 0, sizeof(GroupChat));
 
     int i;
 
     for (i = max_groupchat_index; i > 0; --i) {
-        if (groupchats[i-1].active)
+        if (groupchats[i - 1].active)
             break;
     }
 
     max_groupchat_index = i;
+    kill_groupchat_window(self);
 }
 
-static void print_groupchat_help(ChatContext *ctx)
+static void print_groupchat_help(ToxWindow *self)
 {
-    wattron(ctx->history, COLOR_PAIR(CYAN) | A_BOLD);
-    wprintw(ctx->history, "Group chat commands:\n");
-    wattroff(ctx->history, COLOR_PAIR(CYAN) | A_BOLD);
+    struct history *hst = self->chatwin->hst;
+    line_info_clear(hst);
+    struct line_info *start = hst->line_start;
 
-    wprintw(ctx->history, "      /add <id> <msg>     : Add friend with optional message\n");
-    wprintw(ctx->history, "      /status <type> <msg>: Set your status with optional note\n");
-    wprintw(ctx->history, "      /note <msg>         : Set a personal note\n");
-    wprintw(ctx->history, "      /nick <nick>        : Set your nickname\n");
-    wprintw(ctx->history, "      /groupchat          : Create a group chat\n");
-    wprintw(ctx->history, "      /myid               : Print your ID\n");
-    wprintw(ctx->history, "      /clear              : Clear the screen\n");
-    wprintw(ctx->history, "      /close              : Close the current group chat\n");
-    wprintw(ctx->history, "      /quit or /exit      : Exit Toxic\n");
-    wprintw(ctx->history, "      /help               : Print this message again\n");
+    uint8_t *msg = "Group chat commands:";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
 
-    wattron(ctx->history, COLOR_PAIR(CYAN) | A_BOLD);
-    wprintw(ctx->history, " * Argument messages must be enclosed in quotation marks.\n");
-    wprintw(ctx->history, " * Scroll peer list with the Page Up/Page Down keys.\n\n");
-    wattroff(ctx->history, COLOR_PAIR(CYAN) | A_BOLD);
+#define NUMLINES 9
+
+    uint8_t lines[NUMLINES][MAX_STR_SIZE] = {
+
+        { "    /add <id> <msg>     : Add friend with optional message"               },
+        { "    /status <type> <msg>: Set your status with optional note"             },
+        { "    /note <msg>         : Set a personal note"                            },
+        { "    /nick <nick>        : Set your nickname"                              },
+        { "    /groupchat          : Create a group chat"                            },
+        { "    /log <on> or <off>  : Enable/disable logging"                         },
+        { "    /close              : Close the current group chat"                   },
+        { "    /help               : Print this message again"                       },
+        { "    /help global        : Show a list of global commands"                 },
+
+    };
+
+    int i;
+
+    for (i = 0; i < NUMLINES; ++i)
+        line_info_add(self, NULL, NULL, NULL, lines[i], SYS_MSG, 0, 0);
+
+    msg = " * Use Page Up/Page Down keys to scroll chat history";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
+    msg = " * Scroll peer list with the ctrl-] and ctrl-[ keys.";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, CYAN);
+    msg = " * Notice, some friends will be missing names while finding peers";
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 1, 0);
+    line_info_add(self, NULL, NULL, NULL, "", SYS_MSG, 0, 0);
+
+    hst->line_start = start;
 }
 
 static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, int groupnum, int peernum,
@@ -100,18 +167,24 @@ static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, int groupnum, int
     if (self->num != groupnum)
         return;
 
+    msg[len] = '\0';
+
     ChatContext *ctx = self->chatwin;
 
     uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
-    tox_group_peername(m, groupnum, peernum, nick);
-    nick[TOXIC_MAX_NAME_LENGTH] = '\0';    /* enforce client max name length */
+    int n_len = tox_group_peername(m, groupnum, peernum, nick);
+
+    n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);  /* enforce client max name length */
+    nick[n_len] = '\0';
 
     /* check if message contains own name and alert appropriately */
     int alert_type = WINDOW_ALERT_1;
     bool beep = false;
 
-    uint8_t selfnick[TOX_MAX_NAME_LENGTH] = {'\0'};
-    tox_get_self_name(m, selfnick, TOX_MAX_NAME_LENGTH);
+    uint8_t selfnick[TOX_MAX_NAME_LENGTH];
+    uint16_t sn_len = tox_get_self_name(m, selfnick);
+    selfnick[sn_len] = '\0';
+
     int nick_clr = strcmp(nick, selfnick) == 0 ? GREEN : CYAN;
 
     bool nick_match = strcasestr(msg, selfnick) && strncmp(selfnick, nick, TOXIC_MAX_NAME_LENGTH);
@@ -124,18 +197,11 @@ static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, int groupnum, int
 
     alert_window(self, alert_type, beep);
 
-    print_time(ctx->history);
-    wattron(ctx->history, COLOR_PAIR(nick_clr));
-    wprintw(ctx->history, "%s: ", nick);
-    wattroff(ctx->history, COLOR_PAIR(nick_clr));
+    uint8_t timefrmt[TIME_STR_SIZE];
+    get_time_str(timefrmt);
 
-    if (msg[0] == '>') {
-        wattron(ctx->history, COLOR_PAIR(GREEN));
-        wprintw(ctx->history, "%s\n", msg);
-        wattroff(ctx->history, COLOR_PAIR(GREEN));
-    } else {
-        wprintw(ctx->history, "%s\n", msg);
-    }
+    line_info_add(self, timefrmt, nick, NULL, msg, IN_MSG, 0, nick_clr);
+    write_to_log(msg, nick, ctx->log, false);
 }
 
 static void groupchat_onGroupAction(ToxWindow *self, Tox *m, int groupnum, int peernum, uint8_t *action,
@@ -144,14 +210,17 @@ static void groupchat_onGroupAction(ToxWindow *self, Tox *m, int groupnum, int p
     if (self->num != groupnum)
         return;
 
+    action[len] = '\0';
+
     ChatContext *ctx = self->chatwin;
 
     /* check if message contains own name and alert appropriately */
     int alert_type = WINDOW_ALERT_1;
     bool beep = false;
 
-    uint8_t selfnick[TOX_MAX_NAME_LENGTH] = {'\0'};
-    tox_get_self_name(m, selfnick, TOX_MAX_NAME_LENGTH);
+    uint8_t selfnick[TOX_MAX_NAME_LENGTH];
+    uint16_t n_len = tox_get_self_name(m, selfnick);
+    selfnick[n_len] = '\0';
 
     bool nick_match = strcasestr(action, selfnick);
 
@@ -163,45 +232,63 @@ static void groupchat_onGroupAction(ToxWindow *self, Tox *m, int groupnum, int p
     alert_window(self, alert_type, beep);
 
     uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
-    tox_group_peername(m, groupnum, peernum, nick);
-    nick[TOXIC_MAX_NAME_LENGTH] = '\0';    /* enforce client max name length */
+    n_len = tox_group_peername(m, groupnum, peernum, nick);
 
-    print_time(ctx->history);
-    wattron(ctx->history, COLOR_PAIR(YELLOW));
-    wprintw(ctx->history, "* %s %s\n", nick, action);
-    wattroff(ctx->history, COLOR_PAIR(YELLOW));
+    n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
+    nick[n_len] = '\0';
+
+    uint8_t timefrmt[TIME_STR_SIZE];
+    get_time_str(timefrmt);
+
+    line_info_add(self, timefrmt, nick, NULL, action, ACTION, 0, 0);
+    write_to_log(action, nick, ctx->log, true);
 }
 
-/* Puts two copies of peerlist in chat instance */
-static void copy_peernames(int gnum, int npeers, uint8_t tmp_peerlist[][TOX_MAX_NAME_LENGTH])
+/* Puts two copies of peerlist/lengths in chat instance */
+static void copy_peernames(int gnum, uint8_t peerlist[][TOX_MAX_NAME_LENGTH], uint16_t lengths[], int npeers)
 {
     /* Assumes these are initiated in init_groupchat_win */
     free(groupchats[gnum].peer_names);
     free(groupchats[gnum].oldpeer_names);
+    free(groupchats[gnum].peer_name_lengths);
+    free(groupchats[gnum].oldpeer_name_lengths);
 
     int N = TOX_MAX_NAME_LENGTH;
 
     groupchats[gnum].peer_names = malloc(sizeof(uint8_t) * npeers * N);
     groupchats[gnum].oldpeer_names = malloc(sizeof(uint8_t) * npeers * N);
+    groupchats[gnum].peer_name_lengths = malloc(sizeof(uint16_t) * npeers);
+    groupchats[gnum].oldpeer_name_lengths = malloc(sizeof(uint16_t) * npeers);
 
-    if (groupchats[gnum].peer_names == NULL || groupchats[gnum].oldpeer_names == NULL) {
-        endwin();
-        fprintf(stderr, "malloc() failed. Aborting...\n");
-        exit(EXIT_FAILURE);
+    if (groupchats[gnum].peer_names == NULL || groupchats[gnum].oldpeer_names == NULL
+        || groupchats[gnum].peer_name_lengths == NULL || groupchats[gnum].oldpeer_name_lengths == NULL) {
+        exit_toxic_err("failed in copy_peernames", FATALERR_MEMORY);
     }
 
+    memset(groupchats[gnum].peer_names, 0, sizeof(uint8_t) * npeers * N);
+    memset(groupchats[gnum].peer_name_lengths, 0, sizeof(uint16_t) * npeers);
+
+    uint16_t unknown_len = strlen(UNKNOWN_NAME);
     int i;
 
     for (i = 0; i < npeers; ++i) {
-        if (string_is_empty(tmp_peerlist[i])) {
-            memcpy(&groupchats[gnum].peer_names[i*N], UNKNOWN_NAME, sizeof(UNKNOWN_NAME));
+        if (string_is_empty(peerlist[i])) {
+            memcpy(&groupchats[gnum].peer_names[i * N], UNKNOWN_NAME, sizeof(UNKNOWN_NAME));
+            groupchats[gnum].peer_name_lengths[i] = unknown_len;
         } else {
-            memcpy(&groupchats[gnum].peer_names[i*N], tmp_peerlist[i], N);
-            groupchats[gnum].peer_names[i*N+TOXIC_MAX_NAME_LENGTH] = '\0';
+            memcpy(&groupchats[gnum].peer_names[i * N], peerlist[i], N);
+            uint16_t n_len = lengths[i];
+
+            n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
+
+            groupchats[gnum].peer_names[i * N + n_len] = '\0';
+            groupchats[gnum].peer_name_lengths[i] = n_len;
         }
     }
 
-    memcpy(groupchats[gnum].oldpeer_names, groupchats[gnum].peer_names, N*npeers);
+    memcpy(groupchats[gnum].oldpeer_names, groupchats[gnum].peer_names, N * npeers);
+    memcpy(groupchats[gnum].oldpeer_name_lengths, groupchats[gnum].peer_name_lengths,
+           sizeof(uint16_t) * npeers);
 }
 
 static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnum, int peernum,
@@ -210,89 +297,92 @@ static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnu
     if (self->num != groupnum)
         return;
 
+    if (groupnum > MAX_GROUPCHAT_NUM)
+        return;
+
     groupchats[groupnum].num_peers = tox_group_number_peers(m, groupnum);
     int num_peers = groupchats[groupnum].num_peers;
 
+    if (peernum >= num_peers)
+        return;
+
     /* get old peer name before updating name list */
-    uint8_t oldpeername[TOX_MAX_NAME_LENGTH] = {0};
+    uint8_t oldpeername[TOX_MAX_NAME_LENGTH];
 
-    if (change != TOX_CHAT_CHANGE_PEER_ADD)
-        memcpy(oldpeername, &groupchats[groupnum].oldpeer_names[peernum*TOX_MAX_NAME_LENGTH], 
+    if (change != TOX_CHAT_CHANGE_PEER_ADD) {
+        memcpy(oldpeername, &groupchats[groupnum].oldpeer_names[peernum * TOX_MAX_NAME_LENGTH],
                sizeof(oldpeername));
+        uint16_t old_n_len = groupchats[groupnum].oldpeer_name_lengths[peernum];
+        oldpeername[old_n_len] = '\0';
+    }
 
-    /* Update name lists */
+    /* Update name/len lists */
     uint8_t tmp_peerlist[num_peers][TOX_MAX_NAME_LENGTH];
-    tox_group_get_names(m, groupnum, tmp_peerlist, num_peers);
-    copy_peernames(groupnum, num_peers, tmp_peerlist);
+    uint16_t tmp_peerlens[num_peers];
+    tox_group_get_names(m, groupnum, tmp_peerlist, tmp_peerlens, num_peers);
+    copy_peernames(groupnum, tmp_peerlist, tmp_peerlens, num_peers);
 
     /* get current peername then sort namelist */
-    uint8_t peername[TOX_MAX_NAME_LENGTH] = {0};
-    memcpy(peername, &groupchats[groupnum].peer_names[peernum*TOX_MAX_NAME_LENGTH], sizeof(peername));
+    uint8_t peername[TOX_MAX_NAME_LENGTH];
+
+    if (change != TOX_CHAT_CHANGE_PEER_DEL) {
+        uint16_t n_len = groupchats[groupnum].peer_name_lengths[peernum];
+        memcpy(peername, &groupchats[groupnum].peer_names[peernum * TOX_MAX_NAME_LENGTH], sizeof(peername));
+        peername[n_len] = '\0';
+    }
 
     qsort(groupchats[groupnum].peer_names, groupchats[groupnum].num_peers, TOX_MAX_NAME_LENGTH, qsort_strcasecmp_hlpr);
 
     ChatContext *ctx = self->chatwin;
-    print_time(ctx->history);
+
+    uint8_t *event;
+    uint8_t timefrmt[TIME_STR_SIZE];
+    get_time_str(timefrmt);
 
     switch (change) {
         case TOX_CHAT_CHANGE_PEER_ADD:
-        wattron(ctx->history, COLOR_PAIR(GREEN));
-        wattron(ctx->history, A_BOLD);
-        wprintw(ctx->history, "* %s", peername);
-        wattroff(ctx->history, A_BOLD);
-        wprintw(ctx->history, " has joined the room\n");
-        wattroff(ctx->history, COLOR_PAIR(GREEN));
+            event = "has joined the room";
+            line_info_add(self, timefrmt, peername, NULL, event, CONNECTION, 0, GREEN);
+            write_to_log(event, peername, ctx->log, true);
             break;
+
         case TOX_CHAT_CHANGE_PEER_DEL:
-        wattron(ctx->history, A_BOLD);
-        wprintw(ctx->history, "* %s", oldpeername);
-        wattroff(ctx->history, A_BOLD);
-        wprintw(ctx->history, " has left the room\n");
+            event = "has left the room";
+            line_info_add(self, timefrmt, oldpeername, NULL, event, CONNECTION, 0, 0);
 
             if (groupchats[self->num].side_pos > 0)
                 --groupchats[self->num].side_pos;
 
+            write_to_log(event, oldpeername, ctx->log, true);
             break;
+
         case TOX_CHAT_CHANGE_PEER_NAME:
-        wattron(ctx->history, COLOR_PAIR(MAGENTA));
-        wattron(ctx->history, A_BOLD);
-        wprintw(ctx->history, "* %s", oldpeername);
-        wattroff(ctx->history, A_BOLD);
+            event = " is now known as ";
+            line_info_add(self, timefrmt, oldpeername, peername, event, NAME_CHANGE, 0, 0);
 
-        wprintw(ctx->history, " is now known as ");
-
-        wattron(ctx->history, A_BOLD);
-        wprintw(ctx->history, "%s\n", peername);
-        wattroff(ctx->history, A_BOLD);
-        wattroff(ctx->history, COLOR_PAIR(MAGENTA));
+            uint8_t tmp_event[TOXIC_MAX_NAME_LENGTH * 2 + 32];
+            snprintf(tmp_event, sizeof(tmp_event), "is now known as %s", peername);
+            write_to_log(tmp_event, oldpeername, ctx->log, true);
             break;
     }
 
     alert_window(self, WINDOW_ALERT_2, false);
 }
 
-static void send_group_action(ToxWindow *self, ChatContext *ctx, Tox *m, uint8_t *action) {
+static void send_group_action(ToxWindow *self, ChatContext *ctx, Tox *m, uint8_t *action)
+{
     if (action == NULL) {
         wprintw(ctx->history, "Invalid syntax.\n");
         return;
     }
 
-    // uint8_t selfname[TOX_MAX_NAME_LENGTH];
-    // tox_get_self_name(m, selfname, TOX_MAX_NAME_LENGTH);
-
-    // print_time(ctx->history);
-    // wattron(ctx->history, COLOR_PAIR(YELLOW));
-    // wprintw(ctx->history, "* %s %s\n", selfname, action);
-    // wattroff(ctx->history, COLOR_PAIR(YELLOW));
-
-    if (tox_group_action_send(m, self->num, action, strlen(action) + 1) == -1) {
-        wattron(ctx->history, COLOR_PAIR(RED));
-        wprintw(ctx->history, " * Failed to send action\n");
-        wattroff(ctx->history, COLOR_PAIR(RED));
+    if (tox_group_action_send(m, self->num, action, strlen(action)) == -1) {
+        uint8_t *errmsg = " * Failed to send action.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, RED);
     }
 }
 
-static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
+static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 {
     ChatContext *ctx = self->chatwin;
 
@@ -301,13 +391,28 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
     getmaxyx(self->window, y2, x2);
     int cur_len = 0;
 
+    if (ltr) {
+        if ( (ctx->len < MAX_STR_SIZE - 1) && (ctx->len < (x2 * (CHATBOX_HEIGHT - 1) - 1)) ) {
+            add_char_to_buf(ctx, key);
+
+            if (x == x2 - 1)
+                wmove(self->window, y + 1, 0);
+            else
+                wmove(self->window, y, x + MAX(1, wcwidth(key)));
+        }
+
+    } else { /* if (!ltr) */
+
+        if (line_info_onKey(self, key))
+            return;
+
         if (key == 0x107 || key == 0x8 || key == 0x7f) {  /* BACKSPACE key: Remove character behind pos */
             if (ctx->pos > 0) {
                 cur_len = MAX(1, wcwidth(ctx->line[ctx->pos - 1]));
-            del_char_buf_bck(ctx->line, &ctx->pos, &ctx->len);
+                del_char_buf_bck(ctx);
 
                 if (x == 0)
-                wmove(self->window, y-1, x2 - cur_len);
+                    wmove(self->window, y - 1, x2 - cur_len);
                 else
                     wmove(self->window, y, x - cur_len);
             } else {
@@ -317,14 +422,14 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
 
         else if (key == KEY_DC) {      /* DEL key: Remove character at pos */
             if (ctx->pos != ctx->len)
-            del_char_buf_frnt(ctx->line, &ctx->pos, &ctx->len);
+                del_char_buf_frnt(ctx);
             else
                 beep();
         }
 
         else if (key == T_KEY_DISCARD) {    /* CTRL-U: Delete entire line behind pos */
             if (ctx->pos > 0) {
-            discard_buf(ctx->line, &ctx->pos, &ctx->len);
+                discard_buf(ctx);
                 wmove(self->window, y2 - CURS_Y_OFFSET, 0);
             } else {
                 beep();
@@ -333,22 +438,22 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
 
         else if (key == T_KEY_KILL) {    /* CTRL-K: Delete entire line in front of pos */
             if (ctx->pos != ctx->len)
-            kill_buf(ctx->line, &ctx->pos, &ctx->len);
+                kill_buf(ctx);
             else
                 beep();
         }
 
-    else if (key == KEY_HOME) {    /* HOME key: Move cursor to beginning of line */
+        else if (key == KEY_HOME || key == T_KEY_C_A) {  /* HOME/C-a key: Move cursor to start of line */
             if (ctx->pos > 0) {
                 ctx->pos = 0;
                 wmove(self->window, y2 - CURS_Y_OFFSET, 0);
             }
         }
 
-    else if (key == KEY_END) {     /* END key: move cursor to end of line */
+        else if (key == KEY_END || key == T_KEY_C_E) {  /* END/C-e key: move cursor to end of line */
             if (ctx->pos != ctx->len) {
                 ctx->pos = ctx->len;
-            mv_curs_end(self->window, MAX(0, wcswidth(ctx->line, (CHATBOX_HEIGHT-1)*x2)), y2, x2);
+                mv_curs_end(self->window, MAX(0, wcswidth(ctx->line, (CHATBOX_HEIGHT - 1)*x2)), y2, x2);
             }
         }
 
@@ -358,7 +463,7 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
                 cur_len = MAX(1, wcwidth(ctx->line[ctx->pos]));
 
                 if (x == 0)
-                wmove(self->window, y-1, x2 - cur_len);
+                    wmove(self->window, y - 1, x2 - cur_len);
                 else
                     wmove(self->window, y, x - cur_len);
             } else {
@@ -371,8 +476,8 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
                 cur_len = MAX(1, wcwidth(ctx->line[ctx->pos]));
                 ++ctx->pos;
 
-            if (x == x2-1)
-                wmove(self->window, y+1, 0);
+                if (x == x2 - 1)
+                    wmove(self->window, y + 1, 0);
                 else
                     wmove(self->window, y, x + cur_len);
             } else {
@@ -381,14 +486,12 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
         }
 
         else if (key == KEY_UP) {    /* fetches previous item in history */
-        fetch_hist_item(ctx->line, &ctx->pos, &ctx->len, ctx->ln_history, ctx->hst_tot,
-                        &ctx->hst_pos, LN_HIST_MV_UP);
+            fetch_hist_item(ctx, MOVE_UP);
             mv_curs_end(self->window, ctx->len, y2, x2);
         }
 
         else if (key == KEY_DOWN) {    /* fetches next item in history */
-        fetch_hist_item(ctx->line, &ctx->pos, &ctx->len, ctx->ln_history, ctx->hst_tot,
-                        &ctx->hst_pos, LN_HIST_MV_DWN);
+            fetch_hist_item(ctx, MOVE_DOWN);
             mv_curs_end(self->window, ctx->len, y2, x2);
         }
 
@@ -397,18 +500,17 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
                 int diff;
 
                 if ((ctx->line[0] != '/') || (ctx->line[1] == 'm' && ctx->line[2] == 'e'))
-                diff = complete_line(ctx->line, &ctx->pos, &ctx->len, groupchats[self->num].peer_names, 
+                    diff = complete_line(ctx, groupchats[self->num].peer_names,
                                          groupchats[self->num].num_peers, TOX_MAX_NAME_LENGTH);
                 else
-                diff = complete_line(ctx->line, &ctx->pos, &ctx->len, glob_cmd_list, AC_NUM_GLOB_COMMANDS,
-                                     MAX_CMDNAME_SIZE);
+                    diff = complete_line(ctx, glob_cmd_list, AC_NUM_GLOB_COMMANDS, MAX_CMDNAME_SIZE);
 
                 if (diff != -1) {
                     if (x + diff > x2 - 1) {
                         int ofst = (x + diff - 1) - (x2 - 1);
-                    wmove(self->window, y+1, ofst);
+                        wmove(self->window, y + 1, ofst);
                     } else {
-                    wmove(self->window, y, x+diff);
+                        wmove(self->window, y, x + diff);
                     }
                 } else {
                     beep();
@@ -419,37 +521,22 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
         }
 
         /* Scroll peerlist up and down one position if list overflows window */
-    else if (key == KEY_NPAGE) {
+        else if (key == T_KEY_C_LB) {
             int L = y2 - CHATBOX_HEIGHT - SDBAR_OFST;
 
             if (groupchats[self->num].side_pos < groupchats[self->num].num_peers - L)
                 ++groupchats[self->num].side_pos;
         }
 
-    else if (key == KEY_PPAGE) {
+        else if (key == T_KEY_C_RB) {
             if (groupchats[self->num].side_pos > 0)
                 --groupchats[self->num].side_pos;
         }
 
-    else
-#if HAVE_WIDECHAR
-    if (iswprint(key))
-#else
-    if (isprint(key))
-#endif
-    {   /* prevents buffer overflows and strange behaviour when cursor goes past the window */
-        if ( (ctx->len < MAX_STR_SIZE-1) && (ctx->len < (x2 * (CHATBOX_HEIGHT - 1)-1)) ) {
-            add_char_to_buf(ctx->line, &ctx->pos, &ctx->len, key);
-
-            if (x == x2-1)
-                wmove(self->window, y+1, 0);
-            else
-                wmove(self->window, y, x + MAX(1, wcwidth(key)));
-        }
-    }
-
         /* RETURN key: Execute command or print line */
         else if (key == '\n') {
+            rm_trailing_spaces_buf(ctx);
+
             uint8_t line[MAX_STR_SIZE];
 
             if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
@@ -457,55 +544,57 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key)
 
             wclear(ctx->linewin);
             wmove(self->window, y2 - CURS_Y_OFFSET, 0);
-        wclrtobot(self->window);
-        bool close_win = false;
+
 
             if (!string_is_empty(line))
-            add_line_to_hist(ctx->line, ctx->len, ctx->ln_history, &ctx->hst_tot, &ctx->hst_pos);
+                add_line_to_hist(ctx);
 
             if (line[0] == '/') {
-            if (close_win = strcmp(line, "/close") == 0) {
-                set_active_window(0);
-                int groupnum = self->num;
-                delwin(ctx->linewin);
-                del_window(self);
-                close_groupchatwin(m, groupnum);
-            } else if (strcmp(line, "/help") == 0)
-                print_groupchat_help(ctx);
-              else if (strncmp(line, "/me ", strlen("/me ")) == 0)
-                send_group_action(self, ctx, m, line + strlen("/me "));
+                if (strcmp(line, "/close") == 0) {
+                    close_groupchat(self, m, self->num);
+                    return;
+                } else if (strcmp(line, "/help") == 0) {
+                    if (strcmp(line, "help global") == 0)
+                        execute(ctx->history, self, m, "/help", GLOBAL_COMMAND_MODE);
                     else
+                        print_groupchat_help(self);
+
+                } else if (strncmp(line, "/me ", strlen("/me ")) == 0) {
+                    send_group_action(self, ctx, m, line + strlen("/me "));
+                } else {
                     execute(ctx->history, self, m, line, GROUPCHAT_COMMAND_MODE);
+                }
             } else if (!string_is_empty(line)) {
-            if (tox_group_message_send(m, self->num, line, strlen(line) + 1) == -1) {
-                wattron(ctx->history, COLOR_PAIR(RED));
-                wprintw(ctx->history, " * Failed to send message.\n");
-                wattroff(ctx->history, COLOR_PAIR(RED));
+                if (tox_group_message_send(m, self->num, line, strlen(line)) == -1) {
+                    uint8_t *errmsg = " * Failed to send message.";
+                    line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, RED);
                 }
             }
 
-        if (close_win)
-            free(ctx);
-        else
-            reset_buf(ctx->line, &ctx->pos, &ctx->len);
+            reset_buf(ctx);
+        }
     }
 }
 
 static void groupchat_onDraw(ToxWindow *self, Tox *m)
 {
-    curs_set(1);
+
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
     ChatContext *ctx = self->chatwin;
 
+    line_info_print(self);
     wclear(ctx->linewin);
 
+    scrollok(ctx->history, 0);
+    curs_set(1);
+
     if (ctx->len > 0) {
         uint8_t line[MAX_STR_SIZE];
 
         if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1) {
-            reset_buf(ctx->line, &ctx->pos, &ctx->len);
+            reset_buf(ctx);
             wmove(self->window, y2 - CURS_Y_OFFSET, 0);
         } else {
             mvwprintw(ctx->linewin, 1, 0, "%s", line);
@@ -514,8 +603,8 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
 
     wclear(ctx->sidebar);
     mvwhline(ctx->linewin, 0, 0, ACS_HLINE, x2);
-    mvwvline(ctx->sidebar, 0, 0, ACS_VLINE, y2-CHATBOX_HEIGHT);
-    mvwaddch(ctx->sidebar, y2-CHATBOX_HEIGHT, 0, ACS_BTEE);  
+    mvwvline(ctx->sidebar, 0, 0, ACS_VLINE, y2 - CHATBOX_HEIGHT);
+    mvwaddch(ctx->sidebar, y2 - CHATBOX_HEIGHT, 0, ACS_BTEE);
 
     int num_peers = groupchats[self->num].num_peers;
 
@@ -525,20 +614,20 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
     wattroff(ctx->sidebar, A_BOLD);
 
     mvwaddch(ctx->sidebar, 1, 0, ACS_LTEE);
-    mvwhline(ctx->sidebar, 1, 1, ACS_HLINE, SIDEBAR_WIDTH-1);
+    mvwhline(ctx->sidebar, 1, 1, ACS_HLINE, SIDEBAR_WIDTH - 1);
 
     int N = TOX_MAX_NAME_LENGTH;
     int maxlines = y2 - SDBAR_OFST - CHATBOX_HEIGHT;
     int i;
 
     for (i = 0; i < num_peers && i < maxlines; ++i) {
-        wmove(ctx->sidebar, i+2, 1);
+        wmove(ctx->sidebar, i + 2, 1);
         int peer = i + groupchats[self->num].side_pos;
 
         /* truncate nick to fit in side panel without modifying list */
         uint8_t tmpnck[TOX_MAX_NAME_LENGTH];
-        memcpy(tmpnck, &groupchats[self->num].peer_names[peer*N], SIDEBAR_WIDTH-2);
-        tmpnck[SIDEBAR_WIDTH-2] = '\0';
+        memcpy(tmpnck, &groupchats[self->num].peer_names[peer * N], SIDEBAR_WIDTH - 2);
+        tmpnck[SIDEBAR_WIDTH - 2] = '\0';
 
         wprintw(ctx->sidebar, "%s\n", tmpnck);
     }
@@ -550,13 +639,29 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
     getmaxyx(self->window, y, x);
 
     ChatContext *ctx = self->chatwin;
-    ctx->history = subwin(self->window, y-CHATBOX_HEIGHT+1, x-SIDEBAR_WIDTH-1, 0, 0);
-    scrollok(ctx->history, 1);
-    ctx->linewin = subwin(self->window, CHATBOX_HEIGHT, x, y-CHATBOX_HEIGHT, 0);
-    ctx->sidebar = subwin(self->window, y-CHATBOX_HEIGHT+1, SIDEBAR_WIDTH, 0, x-SIDEBAR_WIDTH);
 
-    print_groupchat_help(ctx);
-    wmove(self->window, y-CURS_Y_OFFSET, 0);
+    ctx->history = subwin(self->window, y - CHATBOX_HEIGHT + 1, x - SIDEBAR_WIDTH - 1, 0, 0);
+    ctx->linewin = subwin(self->window, CHATBOX_HEIGHT, x, y - CHATBOX_HEIGHT, 0);
+    ctx->sidebar = subwin(self->window, y - CHATBOX_HEIGHT + 1, SIDEBAR_WIDTH, 0, x - SIDEBAR_WIDTH);
+
+    ctx->hst = malloc(sizeof(struct history));
+    ctx->log = malloc(sizeof(struct chatlog));
+
+    if (ctx->log == NULL || ctx->hst == NULL)
+        exit_toxic_err("failed in groupchat_onInit", FATALERR_MEMORY);
+
+    memset(ctx->hst, 0, sizeof(struct history));
+    memset(ctx->log, 0, sizeof(struct chatlog));
+
+    line_info_init(ctx->hst);
+    print_groupchat_help(self);
+
+    if (user_settings->autolog == AUTOLOG_ON)
+        log_enable(self->name, NULL, ctx->log);
+
+    execute(ctx->history, self, m, "/log", GLOBAL_COMMAND_MODE);
+
+    wmove(self->window, y - CURS_Y_OFFSET, 0);
 }
 
 ToxWindow new_group_chat(Tox *m, int groupnum)
@@ -565,6 +670,7 @@ ToxWindow new_group_chat(Tox *m, int groupnum)
     memset(&ret, 0, sizeof(ret));
 
     ret.active = true;
+    ret.is_groupchat = true;
 
     ret.onKey = &groupchat_onKey;
     ret.onDraw = &groupchat_onDraw;
@@ -577,14 +683,10 @@ ToxWindow new_group_chat(Tox *m, int groupnum)
 
     ChatContext *chatwin = calloc(1, sizeof(ChatContext));
 
-    if (chatwin != NULL)
-        ret.chatwin = chatwin;
-    else {
-        endwin();
-        fprintf(stderr, "calloc() failed. Aborting...\n");
-        exit(EXIT_FAILURE);
-    }
+    if (chatwin == NULL)
+        exit_toxic_err("failed in new_group_chat", FATALERR_MEMORY);
 
+    ret.chatwin = chatwin;
     ret.num = groupnum;
 
     return ret;

src/groupchat.h

@@ -1,9 +1,34 @@
-/*
- * Toxic -- Tox Curses Client
+/*  groupchat.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
+#ifndef _groupchat_h
+#define _groupchat_h
+
+#include "toxic.h"
+#include "windows.h"
+
 #define SIDEBAR_WIDTH 16
 #define SDBAR_OFST 2    /* Offset for the peer number box at the top of the statusbar */
+#define MAX_GROUPCHAT_NUM MAX_WINDOWS_NUM
 
 typedef struct {
     int chatwin;
@@ -12,7 +37,12 @@ typedef struct {
     int side_pos;    /* current position of the sidebar - used for scrolling up and down */
     uint8_t  *peer_names;
     uint8_t  *oldpeer_names;
+    uint16_t *peer_name_lengths;
+    uint16_t *oldpeer_name_lengths;
 } GroupChat;
 
+void kill_groupchat_window(ToxWindow *self);
 int init_groupchat_win(ToxWindow *prompt, Tox *m, int groupnum);
 ToxWindow new_group_chat(Tox *m, int groupnum);
+
+#endif /* #define _groupchat_h */

src/line_info.c

@@ -0,0 +1,480 @@
+/*  line_info.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include "toxic.h"
+#include "windows.h"
+#include "line_info.h"
+#include "groupchat.h"
+#include "settings.h"
+
+extern struct user_settings *user_settings;
+
+void line_info_init(struct history *hst)
+{
+    hst->line_root = malloc(sizeof(struct line_info));
+
+    if (hst->line_root == NULL)
+        exit_toxic_err("failed in line_info_init", FATALERR_MEMORY);
+
+    memset(hst->line_root, 0, sizeof(struct line_info));
+    hst->line_start = hst->line_root;
+    hst->line_end = hst->line_start;
+    hst->queue_sz = 0;
+}
+
+/* resets line_start */
+static void line_info_reset_start(ToxWindow *self, struct history *hst)
+{
+    int y2, x2;
+    getmaxyx(self->window, y2, x2);
+
+    struct line_info *line = hst->line_end;
+    uint16_t lncnt = 0;
+    int side_offst = self->is_groupchat ? SIDEBAR_WIDTH : 0;
+    int top_offst = self->is_chat ? 3 : 0;
+    int max_y = (y2 - CHATBOX_HEIGHT - top_offst);
+
+    while (line->prev && lncnt < max_y) {
+        line = line->prev;
+        lncnt += (1 + line->len / (x2 - side_offst));
+    }
+
+    hst->line_start = line;
+}
+
+void line_info_cleanup(struct history *hst)
+{
+    struct line_info *tmp1 = hst->line_root;
+
+    while (tmp1) {
+        struct line_info *tmp2 = tmp1->next;
+        free(tmp1);
+        tmp1 = tmp2;
+    }
+}
+
+/* moves root forward and frees previous root */
+static void line_info_root_fwd(struct history *hst)
+{
+    struct line_info *tmp = hst->line_root->next;
+    tmp->prev = NULL;
+
+    if (hst->line_start->prev == NULL) {    /* if line_start is root move it forward as well */
+        hst->line_start = hst->line_start->next;
+        hst->line_start->prev = NULL;
+        ++hst->start_id;
+    }
+
+    free(hst->line_root);
+    hst->line_root = tmp;
+}
+
+/* adds a line_info line to queue */
+static void line_info_add_queue(struct history *hst, struct line_info *line)
+{
+    if (hst->queue_sz >= MAX_QUEUE)
+        return;
+
+    hst->queue[hst->queue_sz++] = line;
+}
+
+/* returns ptr to queue item 0 and removes it from queue */
+static struct line_info *line_info_ret_queue(struct history *hst)
+{
+    if (hst->queue_sz <= 0)
+        return NULL;
+
+    struct line_info *ret = hst->queue[0];
+
+    int i;
+
+    for (i = 0; i < hst->queue_sz; ++i)
+        hst->queue[i] = hst->queue[i + 1];
+
+    --hst->queue_sz;
+
+    return ret;
+}
+
+/* creates new line_info line and puts it in the queue */
+void line_info_add(ToxWindow *self, uint8_t *tmstmp, uint8_t *name1, uint8_t *name2, uint8_t *msg,
+                   uint8_t type, uint8_t bold, uint8_t colour)
+{
+    struct history *hst = self->chatwin->hst;
+    struct line_info *new_line = malloc(sizeof(struct line_info));
+
+    if (new_line == NULL)
+        exit_toxic_err("failed in line_info_add", FATALERR_MEMORY);
+
+    memset(new_line, 0, sizeof(struct line_info));
+
+    int len = 1;     /* there will always be a newline */
+
+    /* for type-specific formatting in print function */
+    switch (type) {
+        case ACTION:
+        case CONNECTION:
+            len += 3;
+            break;
+
+        case SYS_MSG:
+            break;
+
+        case PROMPT:
+            ++len;
+            break;
+
+        default:
+            len += 2;
+            break;
+    }
+
+    if (msg) {
+        snprintf(new_line->msg, sizeof(new_line->msg), "%s", msg);
+        len += strlen(new_line->msg);
+
+        int i;
+
+        for (i = 0; msg[i]; ++i) {
+            if (msg[i] == '\n')
+                ++new_line->newlines;
+        }
+    }
+
+    if (tmstmp) {
+        snprintf(new_line->timestamp, sizeof(new_line->timestamp), "%s", tmstmp);
+        len += strlen(new_line->timestamp);
+    }
+
+    if (name1) {
+        snprintf(new_line->name1, sizeof(new_line->name1), "%s", name1);
+        len += strlen(new_line->name1);
+    }
+
+    if (name2) {
+        snprintf(new_line->name2, sizeof(new_line->name2), "%s", name2);
+        len += strlen(new_line->name2);
+    }
+
+    new_line->len = len;
+    new_line->type = type;
+    new_line->bold = bold;
+    new_line->colour = colour;
+
+    line_info_add_queue(hst, new_line);
+}
+
+/* adds a single queue item to hst if possible. only called once per call to line_info_print() */
+static void line_info_check_queue(ToxWindow *self) 
+{
+    struct history *hst = self->chatwin->hst;
+    struct line_info *line = line_info_ret_queue(hst);
+
+    if (line == NULL)
+        return;
+
+    if (hst->start_id > user_settings->history_size)
+        line_info_root_fwd(hst);
+
+    line->id = hst->line_end->id + 1;
+    line->prev = hst->line_end;
+    hst->line_end->next = line;
+    hst->line_end = line;
+
+    int y, y2, x, x2;
+    getmaxyx(self->window, y2, x2);
+    getyx(self->chatwin->history, y, x);
+
+    if (x2 <= SIDEBAR_WIDTH)
+        return;
+
+    int offst = self->is_groupchat ? SIDEBAR_WIDTH : 0;   /* offset width of groupchat sidebar */
+    int lines = 1 + line->newlines + (line->len / (x2 - offst));
+    int max_y = self->is_prompt ? y2 : y2 - CHATBOX_HEIGHT;
+
+    /* move line_start forward proportionate to the number of new lines */
+    if (y + lines - 1 >= max_y) {
+        while (lines > 0 && hst->line_start->next) {
+            lines -= 1 + hst->line_start->next->newlines + (hst->line_start->next->len / (x2 - offst));
+            hst->line_start = hst->line_start->next;
+            ++hst->start_id;
+        }
+    }
+}
+
+void line_info_print(ToxWindow *self)
+{
+    ChatContext *ctx = self->chatwin;
+
+    if (ctx == NULL)
+        return;
+
+    struct history *hst = ctx->hst;
+
+    /* Only allow one new item to be added to chat window per call to this function */
+    line_info_check_queue(self);
+
+    WINDOW *win = ctx->history;
+    wclear(win);
+    int y2, x2;
+    getmaxyx(self->window, y2, x2);
+
+    if (self->is_prompt)
+        y2 = user_settings->history_size;   /* temporary fix to make prompt scroll */
+
+    if (x2 <= SIDEBAR_WIDTH)
+        return;
+
+    if (self->is_groupchat)
+        wmove(win, 0, 0);
+    else
+        wmove(win, 2, 0);
+
+    struct line_info *line = hst->line_start->next;
+    int offst = self->is_groupchat ? SIDEBAR_WIDTH : 0;
+    int numlines = 0;
+
+    while (line && numlines++ <= y2) {
+        uint8_t type = line->type;
+
+        switch (type) {
+            case OUT_MSG:
+            case IN_MSG:
+                wattron(win, COLOR_PAIR(BLUE));
+                wprintw(win, "%s", line->timestamp);
+                wattroff(win, COLOR_PAIR(BLUE));
+
+                int nameclr = GREEN;
+
+                if (line->colour)
+                    nameclr = line->colour;
+                else if (type == IN_MSG)
+                    nameclr = CYAN;
+
+                wattron(win, COLOR_PAIR(nameclr));
+                wprintw(win, "%s: ", line->name1);
+                wattroff(win, COLOR_PAIR(nameclr));
+
+                if (line->msg[0] == '>')
+                    wattron(win, COLOR_PAIR(GREEN));
+
+                wprintw(win, "%s\n", line->msg);
+
+                if (line->msg[0] == '>')
+                    wattroff(win, COLOR_PAIR(GREEN));
+
+                break;
+
+            case ACTION:
+                wattron(win, COLOR_PAIR(BLUE));
+                wprintw(win, "%s", line->timestamp);
+                wattroff(win, COLOR_PAIR(BLUE));
+
+                wattron(win, COLOR_PAIR(YELLOW));
+                wprintw(win, "* %s %s\n", line->name1, line->msg);
+                wattroff(win, COLOR_PAIR(YELLOW));
+
+                break;
+
+            case SYS_MSG:
+                if (line->timestamp[0]) {
+                    wattron(win, COLOR_PAIR(BLUE));
+                    wprintw(win, "%s", line->timestamp);
+                    wattroff(win, COLOR_PAIR(BLUE));
+                }
+
+                if (line->bold)
+                    wattron(win, A_BOLD);
+
+                if (line->colour)
+                    wattron(win, COLOR_PAIR(line->colour));
+
+                wprintw(win, "%s\n", line->msg);
+
+                if (line->bold)
+                    wattroff(win, A_BOLD);
+
+                if (line->colour)
+                    wattroff(win, COLOR_PAIR(line->colour));
+
+                break;
+
+            case PROMPT:
+                wattron(win, COLOR_PAIR(GREEN));
+                wprintw(win, "$ ");
+                wattroff(win, COLOR_PAIR(GREEN));
+
+                if (line->msg[0])
+                    wprintw(win, "%s", line->msg);
+
+                wprintw(win, "\n");
+                break;
+
+            case CONNECTION:
+                wattron(win, COLOR_PAIR(BLUE));
+                wprintw(win, "%s", line->timestamp);
+                wattroff(win, COLOR_PAIR(BLUE));
+
+                wattron(win, COLOR_PAIR(line->colour));
+                wattron(win, A_BOLD);
+                wprintw(win, "* %s ", line->name1);
+                wattroff(win, A_BOLD);
+                wprintw(win, "%s\n", line->msg);
+                wattroff(win, COLOR_PAIR(line->colour));
+
+                break;
+
+            case NAME_CHANGE:
+                wattron(win, COLOR_PAIR(BLUE));
+                wprintw(win, "%s", line->timestamp);
+                wattroff(win, COLOR_PAIR(BLUE));
+
+                wattron(win, COLOR_PAIR(MAGENTA));
+                wattron(win, A_BOLD);
+                wprintw(win, "* %s", line->name1);
+                wattroff(win, A_BOLD);
+
+                wprintw(win, "%s", line->msg);
+
+                wattron(win, A_BOLD);
+                wprintw(win, "%s\n", line->name2);
+                wattroff(win, A_BOLD);
+                wattroff(win, COLOR_PAIR(MAGENTA));
+
+                break;
+        }
+
+        line = line->next;
+    }
+
+    /* keep calling until queue is empty */
+    if (hst->queue_sz > 0)
+        line_info_print(self);
+}
+
+void line_info_set(ToxWindow *self, uint32_t id, uint8_t *msg)
+{
+    struct line_info *line = self->chatwin->hst->line_end;
+
+    while (line) {
+        if (line->id == id) {
+            snprintf(line->msg, sizeof(line->msg), "%s", msg);
+            return;
+        }
+
+        line = line->prev;
+    }
+}
+
+static void line_info_goto_root(struct history *hst)
+{
+    hst->line_start = hst->line_root;
+}
+
+static void line_info_scroll_up(struct history *hst)
+{
+    if (hst->line_start->prev)
+        hst->line_start = hst->line_start->prev;
+    else beep();
+}
+
+static void line_info_scroll_down(struct history *hst)
+{
+    if (hst->line_start->next)
+        hst->line_start = hst->line_start->next;
+    else beep();
+}
+
+static void line_info_page_up(ToxWindow *self, struct history *hst)
+{
+    int x2, y2;
+    getmaxyx(self->window, y2, x2);
+    int jump_dist = y2 / 2;
+    int i;
+
+    for (i = 0; i < jump_dist && hst->line_start->prev; ++i)
+        hst->line_start = hst->line_start->prev;
+}
+
+static void line_info_page_down(ToxWindow *self, struct history *hst)
+{
+    int x2, y2;
+    getmaxyx(self->window, y2, x2);
+    int jump_dist = y2 / 2;
+    int i;
+
+    for (i = 0; i < jump_dist && hst->line_start->next; ++i)
+        hst->line_start = hst->line_start->next;
+}
+
+bool line_info_onKey(ToxWindow *self, wint_t key)
+{
+    struct history *hst = self->chatwin->hst;
+    bool match = true;
+
+    switch (key) {
+        /* TODO: Find good key bindings for all this stuff */
+        case T_KEY_C_H:
+            line_info_page_up(self, hst);
+            break;
+
+        case T_KEY_C_B:
+            line_info_page_down(self, hst);
+            break; 
+
+        case KEY_PPAGE:
+            line_info_scroll_up(hst);
+            break;
+
+        case KEY_NPAGE:
+            line_info_scroll_down(hst);
+            break;
+
+        /* case ?:
+            line_info_goto_root(hst);
+            break;
+
+        case ?:
+            line_info_reset_start(self, hst);
+            break; */
+
+        default:
+            match = false;
+            break;
+    }
+
+    return match;
+}
+
+void line_info_clear(struct history *hst)
+{
+    hst->line_start = hst->line_end;
+    hst->start_id = hst->line_start->id;
+}

src/line_info.h

@@ -0,0 +1,89 @@
+/*  line_info.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _line_info_h
+#define _line_info_h
+
+#include "windows.h"
+#include "toxic.h"
+
+#define MAX_HISTORY 10000
+#define MIN_HISTORY 20
+#define MAX_QUEUE 32
+
+enum {
+    SYS_MSG,
+    IN_MSG,
+    OUT_MSG,
+    PROMPT,
+    ACTION,
+    CONNECTION,
+    NAME_CHANGE,
+} LINE_TYPE;
+
+struct line_info {
+    uint8_t timestamp[TIME_STR_SIZE];
+    uint8_t name1[TOXIC_MAX_NAME_LENGTH];
+    uint8_t name2[TOXIC_MAX_NAME_LENGTH];
+    uint8_t msg[TOX_MAX_MESSAGE_LENGTH];
+    uint8_t type;
+    uint8_t bold;
+    uint8_t colour;
+    uint32_t id;
+    uint16_t len;   /* combined len of all strings */
+    uint8_t newlines;
+
+    struct line_info *prev;
+    struct line_info *next;
+};
+
+/* Linked list containing chat history lines */
+struct history {
+    struct line_info *line_root;
+    struct line_info *line_start;   /* the first line we want to start printing at */
+    struct line_info *line_end;
+    uint32_t start_id;    /* keeps track of where line_start should be when at bottom of history */
+
+    struct line_info *queue[MAX_QUEUE];
+    int queue_sz;
+};
+
+/* creates new line_info line and puts it in the queue */
+void line_info_add(ToxWindow *self, uint8_t *tmstmp, uint8_t *name1, uint8_t *name2, uint8_t *msg,
+                   uint8_t type, uint8_t bold, uint8_t colour);
+
+/* Prints a section of history starting at line_start */
+void line_info_print(ToxWindow *self);
+
+/* frees all history lines */
+void line_info_cleanup(struct history *hst);
+
+/* clears the screen (does not delete anything) */
+void line_info_clear(struct history *hst);
+
+/* puts msg in specified line_info msg buffer */
+void line_info_set(ToxWindow *self, uint32_t id, uint8_t *msg);
+
+void line_info_init(struct history *hst);
+bool line_info_onKey(ToxWindow *self, wint_t key);    /* returns true if key is a match */
+
+#endif /* #define _line_info_h */

src/log.c

@@ -0,0 +1,135 @@
+/*  log.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "configdir.h"
+#include "toxic.h"
+#include "windows.h"
+#include "misc_tools.h"
+#include "log.h"
+#include "settings.h"
+
+extern struct user_settings *user_settings;
+
+/* Creates/fetches log file by appending to the config dir the name and a pseudo-unique identity */
+void init_logging_session(uint8_t *name, uint8_t *key, struct chatlog *log)
+{
+    if (!log->log_on)
+        return;
+
+    if (!valid_nick(name))
+        name = UNKNOWN_NAME;
+
+    char *user_config_dir = get_user_config_dir();
+    int path_len = strlen(user_config_dir) + strlen(CONFIGDIR) + strlen(name);
+
+    /* use first 4 digits of key as log ident. If no key use a timestamp */
+    uint8_t ident[32];
+
+    if (key != NULL) {
+        path_len += (KEY_IDENT_DIGITS * 2 + 5);
+
+        sprintf(&ident[0], "%02X", key[0] & 0xff);
+        sprintf(&ident[2], "%02X", key[1] & 0xff);
+        ident[KEY_IDENT_DIGITS * 2 + 1] = '\0';
+    } else {
+        strftime(ident, sizeof(ident), "%Y-%m-%d[%H:%M:%S]", get_time());
+        path_len += strlen(ident) + 1;
+    }
+
+    if (path_len > MAX_STR_SIZE) {
+        log->log_on = false;
+        free(user_config_dir);
+        return;
+    }
+
+    uint8_t log_path[MAX_STR_SIZE];
+
+    snprintf(log_path, MAX_STR_SIZE, "%s%s%s-%s.log",
+             user_config_dir, CONFIGDIR, name, ident);
+
+    free(user_config_dir);
+
+    log->file = fopen(log_path, "a");
+
+    if (log->file == NULL) {
+        log->log_on = false;
+        return;
+    }
+
+    fprintf(log->file, "\n*** NEW SESSION ***\n\n");
+}
+
+void write_to_log(const uint8_t *msg, uint8_t *name, struct chatlog *log, bool event)
+{
+    if (!log->log_on)
+        return;
+
+    if (log->file == NULL) {
+        log->log_on = false;
+        return;
+    }
+
+    uint8_t name_frmt[TOXIC_MAX_NAME_LENGTH + 3];
+
+    if (event)
+        snprintf(name_frmt, sizeof(name_frmt), "* %s", name);
+    else
+        snprintf(name_frmt, sizeof(name_frmt), "%s:", name);
+
+    const char *t = user_settings->time == TIME_12 ? "%Y/%m/%d [%I:%M:%S %p]" : "%Y/%m/%d [%H:%M:%S]";
+    uint8_t s[MAX_STR_SIZE];
+    strftime(s, MAX_STR_SIZE, t, get_time());
+    fprintf(log->file, "%s %s %s\n", s, name_frmt, msg);
+
+    uint64_t curtime = get_unix_time();
+
+    if (timed_out(log->lastwrite, curtime, LOG_FLUSH_LIMIT)) {
+        fflush(log->file);
+        log->lastwrite = curtime;
+    }
+}
+
+void log_enable(uint8_t *name, uint8_t *key, struct chatlog *log)
+{
+    log->log_on = true;
+
+    if (log->file == NULL)
+        init_logging_session(name, key, log);
+}
+
+void log_disable(struct chatlog *log)
+{
+    log->log_on = false;
+
+    if (log->file != NULL) {
+        fclose(log->file);
+        log->file = NULL;
+    }
+}

src/log.h

@@ -0,0 +1,47 @@
+/*  log.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _log_h
+#define _log_h
+
+#define LOG_FLUSH_LIMIT 2  /* limits calls to fflush(logfile) to a max of one per LOG_FLUSH_LIMIT seconds */
+
+struct chatlog {
+    FILE *file;
+    uint64_t lastwrite;
+    int pos;
+    bool log_on;    /* specific to current chat window */
+};
+
+/* Creates/fetches log file by appending to the config dir the name and a pseudo-unique identity */
+void init_logging_session(uint8_t *name, uint8_t *key, struct chatlog *log);
+
+/* formats/writes line to log file */
+void write_to_log(const uint8_t *msg, uint8_t *name, struct chatlog *log, bool event);
+
+/* enables logging for specified log and creates/fetches file if necessary */
+void log_enable(uint8_t *name, uint8_t *key, struct chatlog *log);
+
+/* disables logging for specified log and closes file */
+void log_disable(struct chatlog *log);
+
+#endif /* #define _log_h */

src/main.c

@@ -1,563 +0,0 @@
-/*
- * Toxic -- Tox Curses Client
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifndef SIGWINCH
-    #define SIGWINCH 28
-#endif
-
-#include <curses.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <signal.h>
-#include <locale.h>
-#include <string.h>
-#include <time.h>
-
-#ifdef _WIN32
-    #include <direct.h>
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-#else
-#include <netdb.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#endif
-
-#include <tox/tox.h>
-
-#include "configdir.h"
-#include "toxic_windows.h"
-#include "friendlist.h"
-#include "prompt.h"
-#include "misc_tools.h"
-
-#ifndef PACKAGE_DATADIR
-#define PACKAGE_DATADIR "."
-#endif
-
-/* Export for use in Callbacks */
-char *DATA_FILE = NULL;
-char *SRVLIST_FILE = NULL;
-ToxWindow *prompt = NULL;
-
-FileSender file_senders[MAX_FILES];
-uint8_t max_file_senders_index;
-
-void on_window_resize(int sig)
-{
-    endwin();
-    refresh();
-    clear();
-}
-
-static void init_term(void)
-{
-    /* Setup terminal */
-    signal(SIGWINCH, on_window_resize);
-#if HAVE_WIDECHAR
-    if (setlocale(LC_ALL, "") == NULL) {
-        fprintf(stderr, "Could not set your locale, plese check your locale settings or"
-               "disable wide char support\n");
-        exit(EXIT_FAILURE);
-    }
-#endif
-    initscr();
-    cbreak();
-    keypad(stdscr, 1);
-    noecho();
-    timeout(100);
-
-    if (has_colors()) {
-        start_color();
-        init_pair(0, COLOR_WHITE, COLOR_BLACK);
-        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);
-        init_pair(5, COLOR_YELLOW, COLOR_BLACK);
-        init_pair(6, COLOR_MAGENTA, COLOR_BLACK);
-        init_pair(7, COLOR_BLACK, COLOR_BLACK);
-        init_pair(8, COLOR_BLACK, COLOR_WHITE);
-    }
-
-    refresh();
-}
-
-static Tox *init_tox(int ipv4)
-{
-    /* Init core */
-    int ipv6 = !ipv4;
-    Tox *m = tox_new(ipv6);
-
-    if (TOX_ENABLE_IPV6_DEFAULT && m == NULL) {
-        fprintf(stderr, "IPv6 didn't initialize, trying IPv4 only\n");
-        m = tox_new(0);
-    }
-
-    if (m == NULL)
-        return NULL;
-
-    /* Callbacks */
-    tox_callback_connection_status(m, on_connectionchange, NULL);
-    tox_callback_friend_request(m, on_request, NULL);
-    tox_callback_friend_message(m, on_message, NULL);
-    tox_callback_name_change(m, on_nickchange, NULL);
-    tox_callback_user_status(m, on_statuschange, NULL);
-    tox_callback_status_message(m, on_statusmessagechange, NULL);
-    tox_callback_friend_action(m, on_action, NULL);
-    tox_callback_group_invite(m, on_groupinvite, NULL);
-    tox_callback_group_message(m, on_groupmessage, NULL);
-    tox_callback_group_action(m, on_groupaction, NULL);
-    tox_callback_group_namelist_change(m, on_group_namelistchange, NULL);
-    tox_callback_file_send_request(m, on_file_sendrequest, NULL);
-    tox_callback_file_control(m, on_file_control, NULL);
-    tox_callback_file_data(m, on_file_data, NULL);
-
-#ifdef __linux__
-    tox_set_name(m, (uint8_t *) "Cool guy", sizeof("Cool guy"));
-#elif defined(_WIN32)
-    tox_set_name(m, (uint8_t *) "I should install GNU/Linux", sizeof("I should install GNU/Linux"));
-#elif defined(__APPLE__)
-    tox_set_name(m, (uint8_t *) "Hipster", sizeof("Hipster")); //This used to users of other Unixes are hipsters
-#else
-    tox_set_name(m, (uint8_t *) "Registered Minix user #4", sizeof("Registered Minix user #4"));
-#endif
-
-    return m;
-}
-
-#define MINLINE    50 /* IP: 7 + port: 5 + key: 38 + spaces: 2 = 70. ! (& e.g. tox.im = 6) */
-#define MAXLINE   256 /* Approx max number of chars in a sever line (name + port + key) */
-#define MAXSERVERS 50
-#define SERVERLEN (MAXLINE - TOX_CLIENT_ID_SIZE - 7)
-
-static int  linecnt = 0;
-static char servers[MAXSERVERS][SERVERLEN];
-static uint16_t ports[MAXSERVERS];
-static uint8_t keys[MAXSERVERS][TOX_CLIENT_ID_SIZE];
-
-int serverlist_load(void)
-{
-    FILE *fp = NULL;
-
-    fp = fopen(SRVLIST_FILE, "r");
-
-    if (fp == NULL)
-        return 1;
-
-    char line[MAXLINE];
-    while (fgets(line, sizeof(line), fp) && linecnt < MAXSERVERS) {
-        if (strlen(line) > MINLINE) {
-            char *name = strtok(line, " ");
-            char *port = strtok(NULL, " ");
-            char *key_ascii = strtok(NULL, " ");
-            /* invalid line */
-            if (name == NULL || port == NULL || key_ascii == NULL)
-                continue;
-
-            strncpy(servers[linecnt], name, SERVERLEN);
-            servers[linecnt][SERVERLEN - 1] = 0;
-            ports[linecnt] = htons(atoi(port));
-
-            uint8_t *key_binary = hex_string_to_bin(key_ascii);
-            memcpy(keys[linecnt], key_binary, TOX_CLIENT_ID_SIZE);
-            free(key_binary);
-
-            linecnt++;
-        }
-    }
-
-    if (linecnt < 1) {
-        fclose(fp);
-        return 2;
-    }
-
-    fclose(fp);
-    return 0;
-}
-
-int init_connection_helper(Tox *m, int linenumber)
-{
-    return tox_bootstrap_from_address(m, servers[linenumber], TOX_ENABLE_IPV6_DEFAULT,
-                                                ports[linenumber], keys[linenumber]);
-}
-
-/* Connects to a random DHT server listed in the DHTservers file
- *
- * return codes:
- * 1: failed to open server file
- * 2: no line of sufficient length in server file
- * 3: (old, removed) failed to split a selected line in the server file
- * 4: failed to resolve name to IP
- * 5: serverlist file contains no acceptable line
- */
-static int init_connection_serverlist_loaded = 0;
-int init_connection(Tox *m)
-{
-    if (linecnt > 0) /* already loaded serverlist */
-        return init_connection_helper(m, rand() % linecnt) ? 0 : 4;
-
-    /* only once:
-     * - load the serverlist
-     * - connect to "everyone" inside
-     */
-    if (!init_connection_serverlist_loaded) {
-        init_connection_serverlist_loaded = 1;
-        int res = serverlist_load();
-        if (res)
-            return res;
-
-        if (!linecnt)
-            return 4;
-
-        res = 6;
-        int linenumber;
-        for(linenumber = 0; linenumber < linecnt; linenumber++)
-            if (init_connection_helper(m, linenumber))
-                res = 0;
-
-        return res;
-    }
-
-    /* empty serverlist file */
-    return 5;
-}
-
-static void do_connection(Tox *m, ToxWindow *prompt)
-{
-    static int conn_try = 0;
-    static int conn_err = 0;
-    static bool dht_on = false;
-
-    bool is_connected = tox_isconnected(m);
-
-    if (!dht_on && !is_connected && !(conn_try++ % 100)) {
-        prep_prompt_win();
-        if (!conn_err) {
-            wprintw(prompt->window, "Establishing connection...\n");
-            if ((conn_err = init_connection(m)))
-                wprintw(prompt->window, "\nAuto-connect failed with error code %d\n", conn_err);
-        }
-    } else if (!dht_on && is_connected) {
-        dht_on = true;
-        prompt_update_connectionstatus(prompt, dht_on);
-
-        prep_prompt_win();
-        wprintw(prompt->window, "\nDHT connected.\n");
-    } else if (dht_on && !is_connected) {
-        dht_on = false;
-        prompt_update_connectionstatus(prompt, dht_on);
-
-        prep_prompt_win();
-        wprintw(prompt->window, "\nDHT disconnected. Attempting to reconnect.\n");
-    }
-}
-
-int f_loadfromfile;
-
-/*
- * Store Messenger to given location
- * Return 0 stored successfully
- * Return 1 file path is NULL
- * Return 2 malloc failed
- * Return 3 opening path failed
- * Return 4 fwrite failed
- */
-int store_data(Tox *m, char *path)
-{
-    if (f_loadfromfile == 0) /*If file loading/saving is disabled*/
-        return 0;
-
-    if (path == NULL)
-        return 1;
-
-    FILE *fd;
-    size_t len;
-    uint8_t *buf;
-
-    len = tox_size(m);
-    buf = malloc(len);
-
-    if (buf == NULL)
-        return 2;
-
-    tox_save(m, buf);
-
-    fd = fopen(path, "wb");
-
-    if (fd == NULL) {
-        free(buf);
-        return 3;
-    }
-
-    if (fwrite(buf, len, 1, fd) != 1) {
-        free(buf);
-        fclose(fd);
-        return 4;
-    }
-
-    free(buf);
-    fclose(fd);
-    return 0;
-}
-
-static void load_data(Tox *m, char *path)
-{
-    if (f_loadfromfile == 0) /*If file loading/saving is disabled*/
-        return;
-
-    FILE *fd;
-    size_t len;
-    uint8_t *buf;
-
-    if ((fd = fopen(path, "rb")) != NULL) {
-        fseek(fd, 0, SEEK_END);
-        len = ftell(fd);
-        fseek(fd, 0, SEEK_SET);
-
-        buf = malloc(len);
-
-        if (buf == NULL) {
-            fclose(fd);
-            endwin();
-            fprintf(stderr, "malloc() failed. Aborting...\n");
-            exit(EXIT_FAILURE);
-        }
-
-        if (fread(buf, len, 1, fd) != 1) {
-            free(buf);
-            fclose(fd);
-            endwin();
-            fprintf(stderr, "fread() failed. Aborting...\n");
-            exit(EXIT_FAILURE);
-        }
-
-        tox_load(m, buf, len);
-
-        uint32_t i = 0;
-        uint8_t name[TOX_MAX_NAME_LENGTH];
-
-        while (tox_get_name(m, i, name) != -1)
-            on_friendadded(m, i++, false);
-
-        free(buf);
-        fclose(fd);
-    } else {
-        int st;
-
-        if ((st = store_data(m, path)) != 0) {
-            endwin();
-            fprintf(stderr, "Store messenger failed with return code: %d\n", st);
-            exit(EXIT_FAILURE);
-        }
-    }
-}
-
-void close_file_sender(int i)
-{
-    fclose(file_senders[i].file);
-    memset(&file_senders[i], 0, sizeof(FileSender));
-
-    int j;
-
-    for (j = max_file_senders_index; j > 0; --j) {
-        if (file_senders[j-1].active)
-            break;
-    }
-
-    max_file_senders_index = j;
-}
-
-static void do_file_senders(Tox *m)
-{
-    int i;
-
-    for (i = 0; i < max_file_senders_index; ++i) {
-        if (!file_senders[i].active)
-            continue;
-
-        uint8_t *pathname = file_senders[i].pathname;
-        uint8_t filenum = file_senders[i].filenum;
-        int friendnum = file_senders[i].friendnum;
-        FILE *fp = file_senders[i].file;
-        uint64_t current_time = (uint64_t) time(NULL);
-
-        /* If file transfer has timed out kill transfer and send kill control */
-        if (timed_out(file_senders[i].timestamp, current_time, TIMEOUT_FILESENDER)) {
-            ChatContext *ctx = file_senders[i].toxwin->chatwin;
-
-            if (ctx != NULL) {
-                wprintw(ctx->history, "File transfer for '%s' timed out.\n", pathname);
-                alert_window(file_senders[i].toxwin, WINDOW_ALERT_2, true);
-            }
-
-            tox_file_send_control(m, friendnum, 0, filenum, TOX_FILECONTROL_KILL, 0, 0);
-            close_file_sender(i);
-            continue;
-        }
-
-        while (true) {
-            if (tox_file_send_data(m, friendnum, filenum, file_senders[i].nextpiece, 
-                                   file_senders[i].piecelen) == -1)
-                break;
-
-            file_senders[i].timestamp = current_time;
-            file_senders[i].piecelen = fread(file_senders[i].nextpiece, 1, 
-                                             tox_file_data_size(m, friendnum), fp);
-
-            if (file_senders[i].piecelen == 0) {
-                ChatContext *ctx = file_senders[i].toxwin->chatwin;
-
-                if (ctx != NULL) {
-                    wprintw(ctx->history, "File '%s' successfuly sent.\n", pathname);
-                    alert_window(file_senders[i].toxwin, WINDOW_ALERT_2, true);
-                }
-
-                tox_file_send_control(m, friendnum, 0, filenum, TOX_FILECONTROL_FINISHED, 0, 0);
-                close_file_sender(i);
-                break;
-            }
-        }
-    }
-}
-
-void exit_toxic(Tox *m)
-{
-    store_data(m, DATA_FILE);
-
-    int i;
-
-    for (i = 0; i < max_file_senders_index; ++i) {
-        if (file_senders[i].active)
-            fclose(file_senders[i].file);
-    }
-
-    free(DATA_FILE);
-    free(SRVLIST_FILE);
-    free(prompt->stb);
-    free(prompt->promptbuf);
-    tox_kill(m);
-    endwin();
-    exit(EXIT_SUCCESS);
-}
-
-static void do_toxic(Tox *m, ToxWindow *prompt)
-{
-    do_connection(m, prompt);
-    draw_active_window(m);
-    do_file_senders(m);
-
-    /* main tox-core loop */
-    tox_do(m);
-}
-
-int main(int argc, char *argv[])
-{
-    char *user_config_dir = get_user_config_dir();
-    int config_err = 0;
-
-    f_loadfromfile = 1;
-    int f_flag = 0;
-    int i = 0;
-    int f_use_ipv4 = 0;
-
-    // Make sure all written files are read/writeable only by the current user.
-    umask(S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-
-    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)
-                    DATA_FILE = strdup(argv[i + 1]);
-                else
-                    f_flag = -1;
-            } else if (argv[i][1] == 'n') {
-                f_loadfromfile = 0;
-            } else if (argv[i][1] == '4') {
-                f_use_ipv4 = 1;
-            }
-        }
-    }
-
-    config_err = create_user_config_dir(user_config_dir);
-    if (DATA_FILE == NULL ) {
-        if (config_err) {
-            DATA_FILE = strdup("data");
-        } else {
-            DATA_FILE = malloc(strlen(user_config_dir) + strlen(CONFIGDIR) + strlen("data") + 1);
-            if (DATA_FILE != NULL) {
-                strcpy(DATA_FILE, user_config_dir);
-                strcat(DATA_FILE, CONFIGDIR);
-                strcat(DATA_FILE, "data");
-            } else {
-                endwin();
-                fprintf(stderr, "malloc() failed. Aborting...\n");
-                exit(EXIT_FAILURE);
-            }
-        }
-    }
-
-    if (config_err) {
-        SRVLIST_FILE = strdup(PACKAGE_DATADIR "/DHTservers");
-    } else {
-        SRVLIST_FILE = malloc(strlen(user_config_dir) + strlen(CONFIGDIR) + strlen("DHTservers") + 1);
-        if (SRVLIST_FILE != NULL) {
-            strcpy(SRVLIST_FILE, user_config_dir);
-            strcat(SRVLIST_FILE, CONFIGDIR);
-            strcat(SRVLIST_FILE, "DHTservers");
-        } else {
-            endwin();
-            fprintf(stderr, "malloc() failed. Aborting...\n");
-            exit(EXIT_FAILURE);
-        }
-    }
-
-    free(user_config_dir);
-
-    init_term();
-    Tox *m = init_tox(f_use_ipv4);
-
-    if (m == NULL) {
-        endwin();
-        fprintf(stderr, "Failed to initialize network. Aborting...\n");
-        exit(EXIT_FAILURE);
-    }
-
-    prompt = init_windows(m);
-
-    if (f_loadfromfile)
-        load_data(m, DATA_FILE);
-
-    if (f_flag == -1) {
-        attron(COLOR_PAIR(RED) | A_BOLD);
-        wprintw(prompt->window, "You passed '-f' without giving an argument.\n"
-                "defaulting to 'data' for a keyfile...\n");
-        attroff(COLOR_PAIR(RED) | A_BOLD);
-    }
-
-    if (config_err) {
-        attron(COLOR_PAIR(RED) | A_BOLD);
-        wprintw(prompt->window, "Unable to determine configuration directory.\n"
-                "defaulting to 'data' for a keyfile...\n");
-        attroff(COLOR_PAIR(RED) | A_BOLD);
-    }
-
-    prompt_init_statusbar(prompt, m);
-    sort_friendlist_index(m);
-
-    while (true)
-        do_toxic(m, prompt);
-
-    return 0;
-}

src/misc_tools.c

@@ -1,21 +1,73 @@
-/*
- * Toxic -- Tox Curses Client
+/*  misc_tools.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <limits.h>
 
-#include "toxic_windows.h"
+#include "toxic.h"
+#include "windows.h"
+#include "misc_tools.h"
+#include "settings.h"
 
 extern ToxWindow *prompt;
+extern struct user_settings *user_settings;
 
-// XXX: FIX
-unsigned char *hex_string_to_bin(char hex_string[])
+static uint64_t current_unix_time;
+
+void update_unix_time(void)
+{
+    current_unix_time = (uint64_t) time(NULL);
+}
+
+uint64_t get_unix_time(void)
+{
+    return current_unix_time;
+}
+
+/* Get the current local time */
+struct tm *get_time(void)
+{
+    struct tm *timeinfo;
+    uint64_t t = get_unix_time();
+    timeinfo = localtime(&t);
+    return timeinfo;
+}
+
+void get_time_str(uint8_t *buf)
+{
+    const char *t = user_settings->time == TIME_12 ? "[%-I:%M:%S] " : "[%H:%M:%S] ";
+    strftime(buf, TIME_STR_SIZE, t, get_time());
+}
+
+char *hex_string_to_bin(const char *hex_string)
 {
     size_t len = strlen(hex_string);
-    unsigned char *val = malloc(len);
+    char *val = malloc(len);
 
     if (val == NULL) {
         endwin();
@@ -23,35 +75,14 @@ unsigned char *hex_string_to_bin(char hex_string[])
         exit(EXIT_FAILURE);
     }
 
-    char *pos = hex_string;
     size_t i;
 
-    for (i = 0; i < len; ++i, pos += 2)
-        sscanf(pos, "%2hhx", &val[i]);
+    for (i = 0; i < len; ++i, hex_string += 2)
+        sscanf(hex_string, "%2hhx", &val[i]);
 
     return val;
 }
 
-/* Get the current local time */
-struct tm *get_time(void)
-{
-    struct tm *timeinfo;
-    time_t now;
-    time(&now);
-    timeinfo = localtime(&now);
-    return timeinfo;
-}
-
-/* Prints the time to given window */
-void print_time(WINDOW *window)
-{
-    struct tm *timeinfo = get_time();
-
-    wattron(window, COLOR_PAIR(BLUE));
-    wprintw(window, "[%02d:%02d:%02d] ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
-    wattroff(window,COLOR_PAIR(BLUE));
-}
-
 /* Returns 1 if the string is empty, 0 otherwise */
 int string_is_empty(char *string)
 {
@@ -66,7 +97,7 @@ int mbs_to_wcs_buf(wchar_t *buf, const uint8_t *string, size_t n)
     if (n < len)
         return -1;
 
-    if ((len = mbstowcs(buf, string, n)) == (size_t) -1)
+    if ((len = mbstowcs(buf, string, n)) == (size_t) - 1)
         return -1;
 
     return len;
@@ -81,23 +112,23 @@ int wcs_to_mbs_buf(uint8_t *buf, const wchar_t *string, size_t n)
     if (n < len)
         return -1;
 
-    if ((len = wcstombs(buf, string, n)) == (size_t) -1)
+    if ((len = wcstombs(buf, string, n)) == (size_t) - 1)
         return -1;
 
     return len;
 }
 
-/* convert wide characters to multibyte string: string returned must be free'd */
+/* convert wide characters to multibyte string: string returned must be freed */
 uint8_t *wcs_to_mbs(wchar_t *string)
 {
     uint8_t *ret = NULL;
     size_t len = wcstombs(NULL, string, 0);
 
-    if (len != (size_t) -1) {
+    if (len != (size_t) - 1) {
         ret = malloc(++len);
 
         if (ret != NULL) {
-            if (wcstombs(ret, string, len) == (size_t) -1)
+            if (wcstombs(ret, string, len) == (size_t) - 1)
                 return NULL;
         }
     } else {
@@ -134,8 +165,8 @@ char *wc_to_char(wchar_t ch)
     return ret;
 }
 
-/* Returns true if connection has timed out, false otherwise */
-bool timed_out(uint64_t timestamp, uint64_t curtime, uint64_t timeout)
+/* Returns 1 if connection has timed out, 0 otherwise */
+int timed_out(uint64_t timestamp, uint64_t curtime, uint64_t timeout)
 {
     return timestamp + timeout <= curtime;
 }
@@ -147,9 +178,11 @@ void alert_window(ToxWindow *self, int type, bool is_beep)
         case WINDOW_ALERT_0:
             self->alert0 = true;
             break;
+
         case WINDOW_ALERT_1:
             self->alert1 = true;
             break;
+
         case WINDOW_ALERT_2:
             self->alert2 = true;
             break;
@@ -157,7 +190,7 @@ void alert_window(ToxWindow *self, int type, bool is_beep)
 
     StatusBar *stb = prompt->stb;
 
-    if (is_beep && stb->status != TOX_USERSTATUS_BUSY)
+    if (is_beep && stb->status != TOX_USERSTATUS_BUSY && user_settings->alerts == ALERTS_ENABLED)
         beep();
 }
 
@@ -167,23 +200,27 @@ int qsort_strcasecmp_hlpr(const void *nick1, const void *nick2)
     return strcasecmp((const char *) nick1, (const char *) nick2);
 }
 
-/* Returns true if nick is valid. A valid toxic nick:
+/* Returns 1 if nick is valid, 0 if not. A valid toxic nick:
       - cannot be empty
       - cannot start with a space
+      - must not contain a forward slash (for logfile naming purposes)
       - must not contain contiguous spaces */
-bool valid_nick(uint8_t *nick)
+int valid_nick(uint8_t *nick)
 {
     if (!nick[0] || nick[0] == ' ')
-        return false;
+        return 0;
 
     int i;
 
     for (i = 0; nick[i]; ++i) {
-        if (nick[i] == ' ' && nick[i+1] == ' ')
-            return false;
+        if (nick[i] == ' ' && nick[i + 1] == ' ')
+            return 0;
+
+        if (nick[i] == '/')
+            return 0;
     }
 
-    return true;
+    return 1;
 }
 
 /* Moves cursor to the end of the line in given window */
@@ -195,24 +232,30 @@ void mv_curs_end(WINDOW *w, size_t len, int max_y, int max_x)
 }
 
 /* gets base file name from path or original file name if no path is supplied */
-void get_file_name(uint8_t *pathname, uint8_t *namebuf)
+void get_file_name(uint8_t *namebuf, uint8_t *pathname)
 {
     int idx = strlen(pathname) - 1;
 
     while (idx >= 0 && pathname[idx] == '/')
         pathname[idx--] = '\0';
 
-    uint8_t *filename = strrchr(pathname, '/');    // Try unix style paths
+    uint8_t *filename = strrchr(pathname, '/');
 
     if (filename != NULL) {
         if (!strlen(++filename))
             filename = pathname;
     } else {
-        filename = strrchr(pathname, '\\');    // Try windows style paths
-
-        if (filename == NULL)
         filename = pathname;
     }
 
     snprintf(namebuf, MAX_STR_SIZE, "%s", filename);
 }
+
+/* converts str to all lowercase */
+void str_to_lower(uint8_t *str)
+{
+    int i;
+
+    for (i = 0; str[i]; ++i)
+        str[i] = tolower(str[i]);
+}

src/misc_tools.h

@@ -1,18 +1,52 @@
-/*
- * Toxic -- Tox Curses Client
+/*  misc_tools.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
+#ifndef _misc_tools_h
+#define _misc_tools_h
 
-// #define MIN(x, y) (((x) < (y)) ? (x) : (y))
- #define MAX(x, y) (((x) > (y)) ? (x) : (y))
+#include "windows.h"
+#include "toxic.h"
+
+#ifndef MIN
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+#endif
+
+#ifndef MAX
+#define MAX(x, y) (((x) > (y)) ? (x) : (y))
+#endif
 
 /* convert a hex string to binary */
-unsigned char *hex_string_to_bin(char hex_string[]);
+char *hex_string_to_bin(const char *hex_string);
+
+/* get the current unix time */
+uint64_t get_unix_time(void);
+
+/*Puts the current time in buf in the format of [Hour:Min:Sec] */
+void get_time_str(uint8_t *buf);
 
 /* get the current local time */
 struct tm *get_time(void);
 
-/* Prints the time to given window */
-void print_time(WINDOW *window);
+/* updates current unix time (should be run once per do_toxic loop) */
+void update_unix_time(void);
 
 /* Returns 1 if the string is empty, 0 otherwise */
 int string_is_empty(char *string);
@@ -30,8 +64,8 @@ uint8_t *wcs_to_mbs(wchar_t *string);
 /* convert a wide char to multibyte char */
 char *wc_to_char(wchar_t ch);
 
-/* Returns true if connection has timed out, false otherwise */
-bool timed_out(uint64_t timestamp, uint64_t timeout, uint64_t curtime);
+/* Returns 1 if connection has timed out, 0 otherwise */
+int timed_out(uint64_t timestamp, uint64_t timeout, uint64_t curtime);
 
 /* Colours the window tab according to type. Beeps if is_beep is true */
 void alert_window(ToxWindow *self, int type, bool is_beep);
@@ -39,14 +73,20 @@ void alert_window(ToxWindow *self, int type, bool is_beep);
 /* case-insensitive string compare function for use with qsort */
 int qsort_strcasecmp_hlpr(const void *nick1, const void *nick2);
 
-/* Returns true if nick is valid. A valid toxic nick:
+/* Returns 1 if nick is valid, 0 if not. A valid toxic nick:
       - cannot be empty
       - cannot start with a space
+      - must not contain a forward slash (for logfile naming purposes)
       - must not contain contiguous spaces */
-bool valid_nick(uint8_t *nick);
+int valid_nick(uint8_t *nick);
 
 /* Moves the cursor to the end of the line in given window */
 void mv_curs_end(WINDOW *w, size_t len, int max_y, int max_x);
 
 /* gets base file name from path or original file name if no path is supplied */
-void get_file_name(uint8_t *pathname, uint8_t *namebuf);
+void get_file_name(uint8_t *namebuf, uint8_t *pathname);
+
+/* converts str to all uppercase */
+void str_to_lower(uint8_t *str);
+
+#endif /* #define _misc_tools_h */

src/prompt.c

@@ -1,5 +1,23 @@
-/*
- * Toxic -- Tox Curses Client
+/*  prompt.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
 #ifdef HAVE_CONFIG_H
@@ -9,15 +27,22 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "toxic_windows.h"
+#include "toxic.h"
+#include "windows.h"
 #include "prompt.h"
 #include "execute.h"
 #include "misc_tools.h"
 #include "toxic_strings.h"
+#include "log.h"
+#include "line_info.h"
+#include "settings.h"
 
 uint8_t pending_frnd_requests[MAX_FRIENDS_NUM][TOX_CLIENT_ID_SIZE] = {0};
 uint8_t num_frnd_requests = 0;
 extern ToxWindow *prompt;
+struct _Winthread Winthread;
+
+extern struct user_settings *user_settings;
 
 /* Array of global command names used for tab completion. */
 const uint8_t glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE] = {
@@ -30,38 +55,27 @@ const uint8_t glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE] = {
     { "/groupchat"  },
     { "/help"       },
     { "/join"       },
+    { "/log"        },
     { "/myid"       },
     { "/nick"       },
     { "/note"       },
     { "/quit"       },
     { "/status"     },
+
+#ifdef _SUPPORT_AUDIO
+
+    { "/lsdev"       },
+    { "/sdev"        },
+
+#endif /* _SUPPORT_AUDIO */
 };
 
-/* prevents input string from eating system messages: call this prior to printing a prompt message
-   TODO: This is only a partial fix */
-void prep_prompt_win(void)
-{
-    PromptBuf *prt = prompt->promptbuf;
-
-    if (prt->len <= 0)
-        return;
-
-    wprintw(prompt->window, "\n");
-
-    if (!prt->at_bottom) {
-        wmove(prompt->window, prt->orig_y - 1, X_OFST);
-        ++prt->orig_y;
-    } else {
-        wmove(prompt->window, prt->orig_y - 2, X_OFST);
-    }
-}
-
 /* Updates own nick in prompt statusbar */
 void prompt_update_nick(ToxWindow *prompt, uint8_t *nick, uint16_t len)
 {
     StatusBar *statusbar = prompt->stb;
     snprintf(statusbar->nick, sizeof(statusbar->nick), "%s", nick);
-    statusbar->nick_len = len;
+    statusbar->nick_len = strlen(statusbar->nick);
 }
 
 /* Updates own statusmessage in prompt statusbar */
@@ -69,11 +83,11 @@ void prompt_update_statusmessage(ToxWindow *prompt, uint8_t *statusmsg, uint16_t
 {
     StatusBar *statusbar = prompt->stb;
     snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
-    statusbar->statusmsg_len = len;
+    statusbar->statusmsg_len = strlen(statusbar->statusmsg);
 }
 
 /* Updates own status in prompt statusbar */
-void prompt_update_status(ToxWindow *prompt, TOX_USERSTATUS status)
+void prompt_update_status(ToxWindow *prompt, uint8_t status)
 {
     StatusBar *statusbar = prompt->stb;
     statusbar->status = status;
@@ -88,7 +102,7 @@ void prompt_update_connectionstatus(ToxWindow *prompt, bool is_connected)
 
 /* Adds friend request to pending friend requests.
    Returns request number on success, -1 if queue is full or other error. */
-static int add_friend_request(uint8_t *public_key)
+static int add_friend_request(const uint8_t *public_key)
 {
     if (num_frnd_requests >= MAX_FRIENDS_NUM)
         return -1;
@@ -109,153 +123,148 @@ static int add_friend_request(uint8_t *public_key)
     return -1;
 }
 
-static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key)
+static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 {
-    PromptBuf *prt = self->promptbuf;
+    ChatContext *ctx = self->chatwin;
 
     int x, y, y2, x2;
-    getyx(self->window, y, x);
-    getmaxyx(self->window, y2, x2);
+    getyx(ctx->history, y, x);
+    getmaxyx(ctx->history, y2, x2);
+
+    if (ltr) {
+        if (ctx->len < (MAX_STR_SIZE - 1)) {
+            add_char_to_buf(ctx, key);
+        }
+    } else { /* if (!ltr) */
 
         /* BACKSPACE key: Remove one character from line */
         if (key == 0x107 || key == 0x8 || key == 0x7f) {
-        if (prt->pos > 0) {
-            del_char_buf_bck(prt->line, &prt->pos, &prt->len);
-            wmove(self->window, y, x-1);    /* not necessary but fixes a display glitch */
-            prt->scroll = false;
+            if (ctx->pos > 0) {
+                del_char_buf_bck(ctx);
+                wmove(ctx->history, y, x - 1);  /* not necessary but fixes a display glitch */
             } else {
                 beep();
             }
         }
 
         else if (key == KEY_DC) {      /* DEL key: Remove character at pos */
-        if (prt->pos != prt->len) {
-            del_char_buf_frnt(prt->line, &prt->pos, &prt->len);
-            prt->scroll = false;
+            if (ctx->pos != ctx->len) {
+                del_char_buf_frnt(ctx);
             } else {
                 beep();
             }
         }
 
         else if (key == T_KEY_DISCARD) {    /* CTRL-U: Delete entire line behind pos */
-        if (prt->pos > 0) {
-            wmove(self->window, prt->orig_y, X_OFST);
-            wclrtobot(self->window);
-            discard_buf(prt->line, &prt->pos, &prt->len);
+            if (ctx->pos > 0) {
+                wmove(ctx->history, ctx->orig_y, X_OFST);
+                wclrtobot(ctx->history);
+                discard_buf(ctx);
             } else {
                 beep();
             }
         }
 
         else if (key == T_KEY_KILL) {    /* CTRL-K: Delete entire line in front of pos */
-        if (prt->len != prt->pos)
-            kill_buf(prt->line, &prt->pos, &prt->len);
+            if (ctx->len != ctx->pos)
+                kill_buf(ctx);
             else
                 beep();
         }
 
-    else if (key == KEY_HOME) {    /* HOME key: Move cursor to beginning of line */
-        if (prt->pos != 0)
-            prt->pos = 0;
+        else if (key == KEY_HOME || key == T_KEY_C_A) {  /* HOME/C-a key: Move cursor to start of line */
+            if (ctx->pos != 0)
+                ctx->pos = 0;
         }
 
-    else if (key == KEY_END) {     /* END key: move cursor to end of line */
-        if (prt->pos != prt->len)
-            prt->pos = prt->len;
+        else if (key == KEY_END || key == T_KEY_C_E) {   /* END/C-e key: move cursor to end of line */
+            if (ctx->pos != ctx->len)
+                ctx->pos = ctx->len;
         }
 
         else if (key == KEY_LEFT) {
-        if (prt->pos > 0)
-            --prt->pos;
+            if (ctx->pos > 0)
+                --ctx->pos;
             else
                 beep();
         }
 
         else if (key == KEY_RIGHT) {
-        if (prt->pos < prt->len)
-            ++prt->pos;
+            if (ctx->pos < ctx->len)
+                ++ctx->pos;
             else
                 beep();
         }
 
         else if (key == KEY_UP) {     /* fetches previous item in history */
-        wmove(self->window, prt->orig_y, X_OFST);
-        fetch_hist_item(prt->line, &prt->pos, &prt->len, prt->ln_history, prt->hst_tot,
-                        &prt->hst_pos, LN_HIST_MV_UP);
+            wmove(ctx->history, ctx->orig_y, X_OFST);
+            fetch_hist_item(ctx, MOVE_UP);
 
             /* adjust line y origin appropriately when window scrolls down */
-        if (prt->at_bottom && prt->len >= x2 - X_OFST) {
-            int px2 = prt->len >= x2 ? x2 : x2 - X_OFST;
+            if (ctx->at_bottom && ctx->len >= x2 - X_OFST) {
+                int px2 = ctx->len >= x2 ? x2 : x2 - X_OFST;
                 int p_ofst = px2 != x2 ? 0 : X_OFST;
 
                 if (px2 <= 0)
                     return;
 
-            int k = prt->orig_y + ((prt->len + p_ofst) / px2);
+                int k = ctx->orig_y + ((ctx->len + p_ofst) / px2);
 
                 if (k >= y2) {
-                wprintw(self->window, "\n");
-                --prt->orig_y;
+                    --ctx->orig_y;
                 }
             }
         }
 
         else if (key == KEY_DOWN) {    /* fetches next item in history */
-        wmove(self->window, prt->orig_y, X_OFST);
-        fetch_hist_item(prt->line, &prt->pos, &prt->len, prt->ln_history, prt->hst_tot,
-                        &prt->hst_pos, LN_HIST_MV_DWN);
+            wmove(ctx->history, ctx->orig_y, X_OFST);
+            fetch_hist_item(ctx, MOVE_DOWN);
         }
 
         else if (key == '\t') {    /* TAB key: completes command */
-        if (prt->len > 1 && prt->line[0] == '/') {
-            if (complete_line(prt->line, &prt->pos, &prt->len, glob_cmd_list, AC_NUM_GLOB_COMMANDS,
-                              MAX_CMDNAME_SIZE) == -1) 
+            if (ctx->len > 1 && ctx->line[0] == '/') {
+                if (complete_line(ctx, glob_cmd_list, AC_NUM_GLOB_COMMANDS, MAX_CMDNAME_SIZE) == -1)
                     beep();
             } else {
                 beep();
             }
         }
 
-    else
-#if HAVE_WIDECHAR
-    if (iswprint(key))
-#else
-    if (isprint(key))
-#endif
-    {
-        if (prt->len < (MAX_STR_SIZE-1)) {
-            add_char_to_buf(prt->line, &prt->pos, &prt->len, key);
-            prt->scroll = true;
-        }
-    }
         /* RETURN key: execute command */
         else if (key == '\n') {
-        wprintw(self->window, "\n");
-        uint8_t line[MAX_STR_SIZE];
+            rm_trailing_spaces_buf(ctx);
 
-        if (wcs_to_mbs_buf(line, prt->line, MAX_STR_SIZE) == -1)
+            wprintw(ctx->history, "\n");
+            uint8_t line[MAX_STR_SIZE] = {0};
+
+            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
                 memset(&line, 0, sizeof(line));
 
             if (!string_is_empty(line))
-            add_line_to_hist(prt->line, prt->len, prt->ln_history, &prt->hst_tot, &prt->hst_pos);
+                add_line_to_hist(ctx);
 
-        execute(self->window, self, m, line, GLOBAL_COMMAND_MODE);
-        reset_buf(prt->line, &prt->pos, &prt->len);
+            line_info_add(self, NULL, NULL, NULL, line, PROMPT, 0, 0);
+            execute(ctx->history, self, m, line, GLOBAL_COMMAND_MODE);
+            reset_buf(ctx);
+        }
     }
 }
 
 static void prompt_onDraw(ToxWindow *self, Tox *m)
 {
-    PromptBuf *prt = self->promptbuf;
+    ChatContext *ctx = self->chatwin;
+
+    int x, y, x2, y2;
+    getyx(ctx->history, y, x);
+    getmaxyx(ctx->history, y2, x2);
 
     curs_set(1);
-    int x, y, x2, y2;
-    getyx(self->window, y, x);
-    getmaxyx(self->window, y2, x2);
-    wclrtobot(self->window);
+    scrollok(ctx->history, 1);
+
+    line_info_print(self);
 
     /* if len is >= screen width offset max x by X_OFST to account for prompt char */
-    int px2 = prt->len >= x2 ? x2 : x2 - X_OFST;
+    int px2 = ctx->len >= x2 ? x2 : x2 - X_OFST;
 
     if (px2 <= 0)
         return;
@@ -263,33 +272,31 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
     /* len offset to account for prompt char (0 if len is < width of screen) */
     int p_ofst = px2 != x2 ? 0 : X_OFST;
 
-    if (prt->len > 0) {
+    if (ctx->len > 0) {
         uint8_t line[MAX_STR_SIZE];
 
-        if (wcs_to_mbs_buf(line, prt->line, MAX_STR_SIZE) == -1)
-            reset_buf(prt->line, &prt->pos, &prt->len);
+        if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
+            reset_buf(ctx);
         else
-            mvwprintw(self->window, prt->orig_y, X_OFST, line);
+            mvwprintw(ctx->history, ctx->orig_y, X_OFST, line);
 
-        int k = prt->orig_y + ((prt->len + p_ofst) / px2);
+        int k = ctx->orig_y + ((ctx->len + p_ofst) / px2);
 
-        prt->at_bottom = k == y2 - 1;
+        ctx->at_bottom = k == y2 - 1;
         bool botm = k == y2;
-        bool edge = (prt->len + p_ofst) % px2 == 0;
+        bool edge = (ctx->len + p_ofst) % px2 == 0;
 
         /* move point of line origin up when input scrolls screen down */
-        if (prt->scroll && edge && botm) {
-            --prt->orig_y;
-            prt->scroll = false;
-        }
+        if (edge && botm)
+            --ctx->orig_y;
 
     } else {    /* Mark point of origin for new line */
-        prt->orig_y = y;    
+        ctx->orig_y = y;
     }
 
-    wattron(self->window, COLOR_PAIR(GREEN));
-    mvwprintw(self->window, prt->orig_y, 0, "$ ");
-    wattroff(self->window, COLOR_PAIR(GREEN));
+    wattron(ctx->history, COLOR_PAIR(GREEN));
+    mvwprintw(ctx->history, ctx->orig_y, 0, "$ ");
+    wattroff(ctx->history, COLOR_PAIR(GREEN));
 
     StatusBar *statusbar = self->stb;
     werase(statusbar->topline);
@@ -298,141 +305,185 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
 
     if (statusbar->is_online) {
         int colour = WHITE;
-        char *status_text = "Unknown";
+        const uint8_t *status_text = "Unknown";
 
         switch (statusbar->status) {
             case TOX_USERSTATUS_NONE:
                 status_text = "Online";
                 colour = GREEN;
                 break;
+
             case TOX_USERSTATUS_AWAY:
                 status_text = "Away";
                 colour = YELLOW;
                 break;
+
             case TOX_USERSTATUS_BUSY:
                 status_text = "Busy";
                 colour = RED;
                 break;
+
+            case TOX_USERSTATUS_INVALID:
+                status_text = "ERROR";
+                colour = MAGENTA;
+                break;
         }
 
-        wattron(statusbar->topline, A_BOLD);
-        wprintw(statusbar->topline, " %s ", statusbar->nick);
-        wattron(statusbar->topline, A_BOLD);
         wattron(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
-        wprintw(statusbar->topline, "[%s]", status_text);
+        wprintw(statusbar->topline, " [%s]", status_text);
         wattroff(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
+
+        wattron(statusbar->topline, A_BOLD);
+        wprintw(statusbar->topline, " %s", statusbar->nick);
+        wattroff(statusbar->topline, A_BOLD);
     } else {
+        wprintw(statusbar->topline, "[Offline]");
         wattron(statusbar->topline, A_BOLD);
         wprintw(statusbar->topline, " %s ", statusbar->nick);
         wattroff(statusbar->topline, A_BOLD);
-        wprintw(statusbar->topline, "[Offline]");
     }
 
-    wattron(statusbar->topline, A_BOLD);
+    if (statusbar->statusmsg[0])
         wprintw(statusbar->topline, " - %s", statusbar->statusmsg);
-    wattroff(statusbar->topline, A_BOLD);
 
     /* put cursor back in correct spot */
-    int y_m = prt->orig_y + ((prt->pos + p_ofst) / px2);
-    int x_m = (prt->pos + X_OFST) % x2;
+    int y_m = ctx->orig_y + ((ctx->pos + p_ofst) / px2);
+    int x_m = (ctx->pos + X_OFST) % x2;
     wmove(self->window, y_m, x_m);
 }
 
-static void prompt_onInit(ToxWindow *self, Tox *m)
-{
-    scrollok(self->window, true);
-    execute(self->window, self, m, "/help", GLOBAL_COMMAND_MODE);
-    wclrtoeol(self->window);
-}
-
-static void prompt_onConnectionChange(ToxWindow *self, Tox *m, int friendnum , uint8_t status)
+static void prompt_onConnectionChange(ToxWindow *self, Tox *m, int32_t friendnum , uint8_t status)
 {
     if (friendnum < 0)
         return;
 
-    prep_prompt_win();
+    ChatContext *ctx = self->chatwin;
 
-    uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
+    uint8_t nick[TOX_MAX_NAME_LENGTH] = {0};
+    int n_len = tox_get_name(m, friendnum, nick);
+    n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
 
-    if (tox_get_name(m, friendnum, nick) == -1)
-        return;
-
-    if (!nick[0])
+    if (!nick[0]) {
         snprintf(nick, sizeof(nick), "%s", UNKNOWN_NAME);
+        n_len = strlen(UNKNOWN_NAME);
+    }
 
-    wprintw(self->window, "\n");
-    print_time(self->window);
+    nick[n_len] = '\0';
+
+    uint8_t timefrmt[TIME_STR_SIZE];
+    get_time_str(timefrmt);
+    uint8_t *msg;
 
     if (status == 1) {
-        wattron(self->window, COLOR_PAIR(GREEN));
-        wattron(self->window, A_BOLD);
-        wprintw(self->window, "* %s ", nick);
-        wattroff(self->window, A_BOLD);
-        wprintw(self->window, "has come online\n");
-        wattroff(self->window, COLOR_PAIR(GREEN));
-
+        msg = "has come online";
+        line_info_add(self, timefrmt, nick, NULL, msg, CONNECTION, 0, GREEN);
+        write_to_log(msg, nick, ctx->log, true);
         alert_window(self, WINDOW_ALERT_2, false);
     } else {
-        wattron(self->window, COLOR_PAIR(RED));
-        wattron(self->window, A_BOLD);
-        wprintw(self->window, "* %s ", nick);
-        wattroff(self->window, A_BOLD);
-        wprintw(self->window, "has gone offline\n");
-        wattroff(self->window, COLOR_PAIR(RED));
+        msg = "has gone offline";
+        line_info_add(self, timefrmt, nick, NULL, msg, CONNECTION, 0, RED);
+        write_to_log(msg, nick, ctx->log, true);
     }
 }
 
-static void prompt_onFriendRequest(ToxWindow *self, uint8_t *key, uint8_t *data, uint16_t length)
+static void prompt_onFriendRequest(ToxWindow *self, Tox *m, const uint8_t *key, const uint8_t *data,
+                                   uint16_t length)
 {
-    // make sure message data is null-terminated
-    data[length - 1] = 0;
+    ChatContext *ctx = self->chatwin;
 
-    prep_prompt_win();
-    wprintw(self->window, "\n");
-    print_time(self->window);
-    wprintw(self->window, "Friend request with the message: '%s'\n", data);
+    uint8_t timefrmt[TIME_STR_SIZE];
+    get_time_str(timefrmt);
+
+    uint8_t msg[MAX_STR_SIZE];
+    snprintf(msg, sizeof(msg), "Friend request with the message '%s'", data);
+    line_info_add(self, timefrmt, NULL, NULL, msg, SYS_MSG, 0, 0);
+    write_to_log(msg, "", ctx->log, true);
 
     int n = add_friend_request(key);
 
     if (n == -1) {
-        wprintw(self->window, "Friend request queue is full. Discarding request.\n");
+        uint8_t *errmsg = "Friend request queue is full. Discarding request.";
+        line_info_add(self, NULL, NULL, NULL, errmsg, SYS_MSG, 0, 0);
+        write_to_log(errmsg, "", ctx->log, true);
         return;
     }
 
-    wprintw(self->window, "Type \"/accept %d\" to accept it.\n", n);
+    snprintf(msg, sizeof(msg), "Type \"/accept %d\" to accept it.", n);
+    line_info_add(self, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
     alert_window(self, WINDOW_ALERT_1, true);
 }
 
 void prompt_init_statusbar(ToxWindow *self, Tox *m)
 {
-    int x, y;
-    getmaxyx(self->window, y, x);
+    int x2, y2;
+    getmaxyx(self->window, y2, x2);
 
     /* Init statusbar info */
     StatusBar *statusbar = self->stb;
     statusbar->status = TOX_USERSTATUS_NONE;
     statusbar->is_online = false;
 
-    uint8_t nick[TOX_MAX_NAME_LENGTH] = {'\0'};
-    tox_get_self_name(m, nick, TOX_MAX_NAME_LENGTH);
-    snprintf(statusbar->nick, sizeof(statusbar->nick), "%s", nick);
-
-    /* temporary until statusmessage saving works */
-    uint8_t ver[strlen(TOXICVER) + 1];
+    uint8_t nick[TOX_MAX_NAME_LENGTH];
     uint8_t statusmsg[MAX_STR_SIZE];
+
+    pthread_mutex_lock(&Winthread.lock);
+    uint16_t n_len = tox_get_self_name(m, nick);
+    uint16_t s_len = tox_get_self_status_message(m, statusmsg, MAX_STR_SIZE);
+    uint8_t status = tox_get_self_user_status(m);
+    pthread_mutex_unlock(&Winthread.lock);
+
+    nick[n_len] = '\0';
+    statusmsg[s_len] = '\0';
+
+    /* load prev status message or show toxic version if it has never been set */
+    uint8_t ver[strlen(TOXICVER) + 1];
     strcpy(ver, TOXICVER);
-    uint8_t *toxic_ver = strtok(ver, "_");
+    const uint8_t *toxic_ver = strtok(ver, "_");
 
-    if (toxic_ver != NULL)
+    if ( (!strcmp("Online", statusmsg) || !strncmp("Toxing on Toxic", statusmsg, 15)) && toxic_ver != NULL) {
         snprintf(statusmsg, MAX_STR_SIZE, "Toxing on Toxic v.%s", toxic_ver);
-    else
-        snprintf(statusmsg, MAX_STR_SIZE, "Toxing on Toxic hacker edition");
+        s_len = strlen(statusmsg);
+        statusmsg[s_len] = '\0';
+    }
 
-    m_set_statusmessage(m, statusmsg, strlen(statusmsg) + 1);
-    snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
+    prompt_update_statusmessage(prompt, statusmsg, s_len);
+    prompt_update_status(prompt, status);
+    prompt_update_nick(prompt, nick, n_len);
 
     /* Init statusbar subwindow */
-    statusbar->topline = subwin(self->window, 2, x, 0, 0);
+    statusbar->topline = subwin(self->window, 2, x2, 0, 0);
+}
+
+static void prompt_onInit(ToxWindow *self, Tox *m)
+{
+    ChatContext *ctx = self->chatwin;
+
+    curs_set(1);
+    int y2, x2;
+    getmaxyx(self->window, y2, x2);
+
+    ctx->history = subwin(self->window, y2, x2, 0, 0);
+    scrollok(ctx->history, 1);
+
+    ctx->log = malloc(sizeof(struct chatlog));
+    ctx->hst = malloc(sizeof(struct history));
+
+    if (ctx->log == NULL || ctx->hst == NULL)
+        exit_toxic_err("failed in prompt_onInit", FATALERR_MEMORY);
+
+    memset(ctx->log, 0, sizeof(struct chatlog));
+    memset(ctx->hst, 0, sizeof(struct history));
+
+    line_info_init(ctx->hst);
+
+    if (user_settings->autolog == AUTOLOG_ON) {
+        uint8_t myid[TOX_FRIEND_ADDRESS_SIZE];
+        tox_get_address(m, myid);
+        log_enable(self->name, myid, ctx->log);
+    }
+
+    execute(ctx->history, self, m, "/help", GLOBAL_COMMAND_MODE);
+    wmove(ctx->history, y2 - 1, 2);
 }
 
 ToxWindow new_prompt(void)
@@ -441,6 +492,7 @@ ToxWindow new_prompt(void)
     memset(&ret, 0, sizeof(ret));
 
     ret.active = true;
+    ret.is_prompt = true;
 
     ret.onKey = &prompt_onKey;
     ret.onDraw = &prompt_onDraw;
@@ -450,17 +502,14 @@ ToxWindow new_prompt(void)
 
     strcpy(ret.name, "prompt");
 
-    PromptBuf *promptbuf = calloc(1, sizeof(PromptBuf));
+    ChatContext *chatwin = calloc(1, sizeof(ChatContext));
     StatusBar *stb = calloc(1, sizeof(StatusBar));
 
-    if (stb != NULL && promptbuf != NULL) {
-        ret.promptbuf = promptbuf;
+    if (stb == NULL || chatwin == NULL)
+        exit_toxic_err("failed in new_prompt", FATALERR_MEMORY);
+
+    ret.chatwin = chatwin;
     ret.stb = stb;
-    } else {
-        endwin();
-        fprintf(stderr, "calloc() failed. Aborting...\n");
-        exit(EXIT_FAILURE);
-    }
 
     return ret;
 }

src/prompt.h

@@ -1,20 +1,45 @@
-/*
- * Toxic -- Tox Curses Client
+/*  prompt.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
 #ifndef PROMPT_H_UZYGWFFL
 #define PROMPT_H_UZYGWFFL
 
+#include "toxic.h"
+#include "windows.h"
+
 #define X_OFST 2    /* offset to account for prompt char */
 
-#define AC_NUM_GLOB_COMMANDS 14
+#ifdef _SUPPORT_AUDIO
+#define AC_NUM_GLOB_COMMANDS 17
+#else
+#define AC_NUM_GLOB_COMMANDS 15
+#endif /* _SUPPORT_AUDIO */
 
 ToxWindow new_prompt(void);
 void prep_prompt_win(void);
 void prompt_init_statusbar(ToxWindow *self, Tox *m);
 void prompt_update_nick(ToxWindow *prompt, uint8_t *nick, uint16_t len);
 void prompt_update_statusmessage(ToxWindow *prompt, uint8_t *statusmsg, uint16_t len);
-void prompt_update_status(ToxWindow *prompt, TOX_USERSTATUS status);
+void prompt_update_status(ToxWindow *prompt, uint8_t status);
 void prompt_update_connectionstatus(ToxWindow *prompt, bool is_connected);
 
 #endif /* end of include guard: PROMPT_H_UZYGWFFL */

src/settings.c

@@ -0,0 +1,221 @@
+/*  settings.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "toxic.h"
+#include "windows.h"
+#include "configdir.h"
+
+#ifdef _SUPPORT_AUDIO
+#include "audio_call.h"
+#endif
+
+#include "settings.h"
+#include "line_info.h"
+
+static void uset_autolog(struct user_settings *s, const char *val);
+static void uset_time(struct user_settings *s, const char *val);
+static void uset_alerts(struct user_settings *s, const char *val);
+static void uset_colours(struct user_settings *s, const char *val);
+static void uset_hst_size(struct user_settings *s, const char *val);
+static void uset_dwnld_path(struct user_settings *s, const char *val);
+
+#ifdef _SUPPORT_AUDIO
+static void uset_ain_dev(struct user_settings *s, const char *val);
+static void uset_aout_dev(struct user_settings *s, const char *val);
+#endif
+
+struct {
+    const char *key;
+    void (*func)(struct user_settings *s, const char *val);
+} user_settings_list[] = {
+    { "autolog",        uset_autolog    },
+    { "time",           uset_time       },
+    { "disable_alerts", uset_alerts     },
+    { "colour_theme",   uset_colours    },
+    { "history_size",   uset_hst_size   },
+    { "download_path",  uset_dwnld_path },
+
+#ifdef _SUPPORT_AUDIO
+    { "audio_in_dev",   uset_ain_dev    },
+    { "audio_out_dev",  uset_aout_dev   },
+#endif
+};
+
+static void uset_autolog(struct user_settings *s, const char *val)
+{
+    int n = atoi(val);
+
+    /* default off if invalid value */
+    s->autolog = n == AUTOLOG_ON ? AUTOLOG_ON : AUTOLOG_OFF;
+}
+
+static void uset_time(struct user_settings *s, const char *val)
+{
+    int n = atoi(val);
+
+    /* default to 24 hour time if invalid value */
+    s->time = n == TIME_12 ? TIME_12 : TIME_24;
+}
+
+static void uset_alerts(struct user_settings *s, const char *val)
+{
+    int n = atoi(val);
+
+    /* alerts default on if invalid value */
+    s->alerts = n == ALERTS_DISABLED ? ALERTS_DISABLED : ALERTS_ENABLED;
+}
+
+static void uset_colours(struct user_settings *s, const char *val)
+{
+    int n = atoi(val);
+
+    /* use default toxic colours if invalid value */
+    s->colour_theme = n == NATIVE_COLS ? NATIVE_COLS : DFLT_COLS;
+}
+
+#ifdef _SUPPORT_AUDIO
+
+static void uset_ain_dev(struct user_settings *s, const char *val)
+{
+    int n = atoi(val);
+
+    if (n < 0 || n > MAX_DEVICES)
+        n = (long int) 0;
+
+    s->audio_in_dev = (long int) n;
+}
+
+static void uset_aout_dev(struct user_settings *s, const char *val)
+{
+    int n = atoi(val);
+
+    if (n < 0 || n > MAX_DEVICES)
+        n = (long int) 0;
+
+    s->audio_out_dev = (long int) n;
+}
+
+#endif /* _SUPPORT_AUDIO */
+
+static void uset_hst_size(struct user_settings *s, const char *val)
+{
+    int n = atoi(val);
+
+    /* if val is out of range use default history size */
+    s->history_size = (n > MAX_HISTORY || n < MIN_HISTORY) ? DFLT_HST_SIZE : n;
+}
+
+static void uset_dwnld_path(struct user_settings *s, const char *val)
+{
+    memset(s->download_path, 0, sizeof(s->download_path));
+
+    if (val == NULL)
+        return;
+
+    int len = strlen(val);
+
+    if (len >= sizeof(s->download_path) - 2)  /* leave room for null and '/' */
+        return;
+
+    FILE *fp = fopen(val, "r");
+
+    if (fp == NULL)
+        return;
+
+    strcpy(s->download_path, val);
+
+    if (val[len - 1] != '/')
+        strcat(s->download_path, "/");
+}
+
+static void set_default_settings(struct user_settings *s)
+{
+    /* see settings_values enum in settings.h for defaults */
+    uset_autolog(s, "0");
+    uset_time(s, "24");
+    uset_alerts(s, "0");
+    uset_colours(s, "0");
+    uset_hst_size(s, "700");
+    uset_dwnld_path(s, NULL);
+
+#ifdef _SUPPORT_AUDIO
+    uset_ain_dev(s, "0");
+    uset_aout_dev(s, "0");
+#endif
+}
+
+int settings_load(struct user_settings *s, char *path)
+{
+    char *user_config_dir = get_user_config_dir();
+    FILE *fp = NULL;
+    char dflt_path[MAX_STR_SIZE];
+
+    if (path) {
+        fp = fopen(path, "r");
+    } else {
+        snprintf(dflt_path, sizeof(dflt_path), "%s%stoxic.conf", user_config_dir, CONFIGDIR);
+        fp = fopen(dflt_path, "r");
+    }
+
+    free(user_config_dir);
+
+    set_default_settings(s);
+
+    if (fp == NULL && !path) {
+        if ((fp = fopen(dflt_path, "w")) == NULL)
+            return -1;
+    } else if (fp == NULL && path) {
+        return -1;
+    }
+
+    char line[MAX_STR_SIZE];
+
+    while (fgets(line, sizeof(line), fp)) {
+        if (line[0] == '#' || !line[0])
+            continue;
+
+        const char *key = strtok(line, ":");
+        const char *val = strtok(NULL, ";");
+
+        if (key == NULL || val == NULL)
+            continue;
+
+        int i;
+
+        for (i = 0; i < NUM_SETTINGS; ++i) {
+            if (!strcmp(user_settings_list[i].key, key)) {
+                (user_settings_list[i].func)(s, val);
+                break;
+            }
+        }
+    }
+
+    fclose(fp);
+    return 0;
+}

src/settings.h

@@ -0,0 +1,67 @@
+/*  settings.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _settings_h
+#define _settings_h
+
+#include "toxic.h"
+
+#ifdef _SUPPORT_AUDIO
+    #define NUM_SETTINGS 8
+#else
+    #define NUM_SETTINGS 6
+#endif
+
+/* holds user setting values */
+struct user_settings {
+    int autolog;           /* boolean */
+    int alerts;            /* boolean */
+    int time;              /* 12 or 24 */
+    int colour_theme;      /* boolean (0 for default toxic colours) */
+    int history_size;      /* int between MIN_HISTORY and MAX_HISTORY */
+    char download_path[MAX_STR_SIZE];
+
+#ifdef _SUPPORT_AUDIO
+    long int audio_in_dev;
+    long int audio_out_dev;
+#endif
+};
+
+enum {
+    AUTOLOG_OFF = 0,
+    AUTOLOG_ON = 1,
+
+    TIME_24 = 24,
+    TIME_12 = 12,
+
+    ALERTS_DISABLED = 1,
+    ALERTS_ENABLED = 0,
+
+    NATIVE_COLS = 1,
+    DFLT_COLS = 0,
+
+    DFLT_HST_SIZE = 700,
+} settings_values;
+
+int settings_load(struct user_settings *s, char *path);
+
+#endif /* #define _settings_h */

src/toxic.c

@@ -0,0 +1,633 @@
+/*  main.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef SIGWINCH
+#define SIGWINCH 28
+#endif
+
+#include <curses.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <signal.h>
+#include <locale.h>
+#include <string.h>
+#include <time.h>
+#include <pthread.h>
+#include <getopt.h>
+#include <netdb.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <tox/tox.h>
+
+#include "configdir.h"
+#include "toxic.h"
+#include "windows.h"
+#include "friendlist.h"
+#include "prompt.h"
+#include "misc_tools.h"
+#include "file_senders.h"
+#include "line_info.h"
+#include "settings.h"
+
+#ifdef _SUPPORT_AUDIO
+#include "audio_call.h"
+#endif /* _SUPPORT_AUDIO */
+
+#ifndef PACKAGE_DATADIR
+#define PACKAGE_DATADIR "."
+#endif
+
+#ifdef _SUPPORT_AUDIO
+ToxAv *av;
+#endif /* _SUPPORT_AUDIO */
+
+/* Export for use in Callbacks */
+char *DATA_FILE = NULL;
+ToxWindow *prompt = NULL;
+
+struct arg_opts {
+    int ignore_data_file;
+    int use_ipv4;
+    char config_path[MAX_STR_SIZE];
+    char nodes_path[MAX_STR_SIZE];
+} arg_opts;
+
+struct _Winthread Winthread;
+struct user_settings *user_settings = NULL;
+
+static void ignore_SIGINT(int sig)
+{
+    return;
+}
+
+void exit_toxic_success(Tox *m)
+{
+    store_data(m, DATA_FILE);
+    close_all_file_senders();
+    kill_all_windows();
+    log_disable(prompt->chatwin->log);
+    line_info_cleanup(prompt->chatwin->hst);
+    free(DATA_FILE);
+    free(prompt->stb);
+    free(prompt->chatwin->log);
+    free(prompt->chatwin->hst);
+    free(prompt->chatwin);
+    free(user_settings);
+#ifdef _SUPPORT_AUDIO
+    terminate_audio();
+#endif /* _SUPPORT_AUDIO */
+    tox_kill(m);
+    endwin();
+    fprintf(stderr, "Toxic session ended gracefully.\n");
+    exit(EXIT_SUCCESS);
+}
+
+void exit_toxic_err(const char *errmsg, int errcode)
+{
+    if (errmsg == NULL)
+        errmsg = "No error message";
+
+    endwin();
+    fprintf(stderr, "Toxic session aborted with error code %d (%s)\n", errcode, errmsg);
+    exit(EXIT_FAILURE);
+}
+
+static void init_term(void)
+{
+    signal(SIGWINCH, on_window_resize);
+
+#if HAVE_WIDECHAR
+
+    if (setlocale(LC_ALL, "") == NULL)
+        exit_toxic_err("Could not set your locale, plese check your locale settings or"
+                       "disable wide char support", FATALERR_LOCALE_SET);
+#endif
+
+    initscr();
+    cbreak();
+    keypad(stdscr, 1);
+    noecho();
+    timeout(100);
+
+    if (has_colors()) {
+        short bg_color = COLOR_BLACK;
+        start_color();
+
+        if (user_settings->colour_theme == NATIVE_COLS) {
+            if (assume_default_colors(-1, -1) == OK)
+                bg_color = -1;
+        }
+
+        init_pair(0, COLOR_WHITE, COLOR_BLACK);
+        init_pair(1, COLOR_GREEN, bg_color);
+        init_pair(2, COLOR_CYAN, bg_color);
+        init_pair(3, COLOR_RED, bg_color);
+        init_pair(4, COLOR_BLUE, bg_color);
+        init_pair(5, COLOR_YELLOW, bg_color);
+        init_pair(6, COLOR_MAGENTA, bg_color);
+        init_pair(7, COLOR_BLACK, COLOR_BLACK);
+        init_pair(8, COLOR_BLACK, COLOR_WHITE);
+    }
+
+    refresh();
+}
+
+static Tox *init_tox(int ipv4)
+{
+    /* Init core */
+    int ipv6 = !ipv4;
+    Tox *m = tox_new(ipv6);
+
+    /*
+    * TOX_ENABLE_IPV6_DEFAULT is always 1.
+    * Checking it is redundant, this *should* be doing ipv4 fallback
+    */
+    if (ipv6 && m == NULL) {
+        fprintf(stderr, "IPv6 didn't initialize, trying IPv4\n");
+        m = tox_new(0);
+    }
+
+    if (ipv4)
+        fprintf(stderr, "Forcing IPv4 connection\n");
+
+    if (m == NULL)
+        return NULL;
+
+    /* Callbacks */
+    tox_callback_connection_status(m, on_connectionchange, NULL);
+    tox_callback_typing_change(m, on_typing_change, NULL);
+    tox_callback_friend_request(m, on_request, NULL);
+    tox_callback_friend_message(m, on_message, NULL);
+    tox_callback_name_change(m, on_nickchange, NULL);
+    tox_callback_user_status(m, on_statuschange, NULL);
+    tox_callback_status_message(m, on_statusmessagechange, NULL);
+    tox_callback_friend_action(m, on_action, NULL);
+    tox_callback_group_invite(m, on_groupinvite, NULL);
+    tox_callback_group_message(m, on_groupmessage, NULL);
+    tox_callback_group_action(m, on_groupaction, NULL);
+    tox_callback_group_namelist_change(m, on_group_namelistchange, NULL);
+    tox_callback_file_send_request(m, on_file_sendrequest, NULL);
+    tox_callback_file_control(m, on_file_control, NULL);
+    tox_callback_file_data(m, on_file_data, NULL);
+
+#ifdef __linux__
+    tox_set_name(m, (uint8_t *) "Cool dude", strlen("Cool dude"));
+#elif defined(__FreeBSD__)
+    tox_set_name(m, (uint8_t *) "Nerd", strlen("Nerd"));
+#elif defined(__APPLE__)
+    tox_set_name(m, (uint8_t *) "Hipster", strlen("Hipster")); /* This used to users of other Unixes are hipsters */
+#else
+    tox_set_name(m, (uint8_t *) "Registered Minix user #4", strlen("Registered Minix user #4"));
+#endif
+
+    return m;
+}
+
+#define MINLINE  50 /* IP: 7 + port: 5 + key: 38 + spaces: 2 = 70. ! (& e.g. tox.im = 6) */
+#define MAXLINE  256 /* Approx max number of chars in a sever line (name + port + key) */
+#define MAXNODES 50
+#define NODELEN (MAXLINE - TOX_CLIENT_ID_SIZE - 7)
+
+static int  linecnt = 0;
+static char nodes[MAXNODES][NODELEN];
+static uint16_t ports[MAXNODES];
+static uint8_t keys[MAXNODES][TOX_CLIENT_ID_SIZE];
+
+static int nodelist_load(char *filename)
+{
+    if (!filename)
+        return 1;
+
+    FILE *fp = fopen(filename, "r");
+
+    if (fp == NULL)
+        return 1;
+
+    char line[MAXLINE];
+
+    while (fgets(line, sizeof(line), fp) && linecnt < MAXNODES) {
+        if (strlen(line) > MINLINE) {
+            const char *name = strtok(line, " ");
+            const char *port = strtok(NULL, " ");
+            const char *key_ascii = strtok(NULL, " ");
+
+            /* invalid line */
+            if (name == NULL || port == NULL || key_ascii == NULL)
+                continue;
+
+            snprintf(nodes[linecnt], sizeof(nodes[linecnt]), "%s", name);
+            nodes[linecnt][NODELEN - 1] = 0;
+            ports[linecnt] = htons(atoi(port));
+
+            uint8_t *key_binary = hex_string_to_bin(key_ascii);
+            memcpy(keys[linecnt], key_binary, TOX_CLIENT_ID_SIZE);
+            free(key_binary);
+
+            linecnt++;
+        }
+    }
+
+    if (linecnt < 1) {
+        fclose(fp);
+        return 2;
+    }
+
+    fclose(fp);
+    return 0;
+}
+
+int init_connection_helper(Tox *m, int line)
+{
+    return tox_bootstrap_from_address(m, nodes[line], TOX_ENABLE_IPV6_DEFAULT,
+                                      ports[line], keys[line]);
+}
+
+/* Connects to a random DHT node listed in the DHTnodes file
+ *
+ * return codes:
+ * 1: failed to open node file
+ * 2: no line of sufficient length in node file
+ * 3: failed to resolve name to IP
+ * 4: nodelist file contains no acceptable line
+ */
+static bool srvlist_loaded = false;
+
+#define NUM_INIT_NODES 5
+
+int init_connection(Tox *m)
+{
+    if (linecnt > 0) /* already loaded nodelist */
+        return init_connection_helper(m, rand() % linecnt) ? 0 : 3;
+
+    /* only once:
+     * - load the nodelist
+     * - connect to "everyone" inside
+     */
+    if (!srvlist_loaded) {
+        srvlist_loaded = true;
+        int res;
+
+        if (!arg_opts.nodes_path[0])
+            res = nodelist_load(PACKAGE_DATADIR "/DHTnodes");
+        else
+            res = nodelist_load(arg_opts.nodes_path);
+
+        if (linecnt < 1)
+            return res;
+
+        res = 3;
+        int i;
+        int n = MIN(NUM_INIT_NODES, linecnt);
+
+        for (i = 0; i < n; ++i) {
+            if (init_connection_helper(m, rand() % linecnt))
+                res = 0;
+        }
+
+        return res;
+    }
+
+    /* empty nodelist file */
+    return 4;
+}
+
+static void do_connection(Tox *m, ToxWindow *prompt)
+{
+    uint8_t msg[MAX_STR_SIZE] = {0};
+
+    static int conn_try = 0;
+    static int conn_err = 0;
+    static bool dht_on = false;
+
+    bool is_connected = tox_isconnected(m);
+
+    if (!dht_on && !is_connected && !(conn_try++ % 100)) {
+        if (!conn_err) {
+            if ((conn_err = init_connection(m))) {
+                snprintf(msg, sizeof(msg), "\nAuto-connect failed with error code %d", conn_err);
+            }
+        }
+    } else if (!dht_on && is_connected) {
+        dht_on = true;
+        prompt_update_connectionstatus(prompt, dht_on);
+        snprintf(msg, sizeof(msg), "DHT connected.");
+    } else if (dht_on && !is_connected) {
+        dht_on = false;
+        prompt_update_connectionstatus(prompt, dht_on);
+        snprintf(msg, sizeof(msg), "\nDHT disconnected. Attempting to reconnect.");
+    }
+
+    if (msg[0])
+        line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+}
+
+static void load_friendlist(Tox *m)
+{
+    uint32_t i;
+    uint32_t numfriends = tox_count_friendlist(m);
+
+    for (i = 0; i < numfriends; ++i)
+        friendlist_onFriendAdded(NULL, m, i, false);
+}
+
+/*
+ * Store Messenger to given location
+ * Return 0 stored successfully
+ * Return 1 file path is NULL
+ * Return 2 malloc failed
+ * Return 3 opening path failed
+ * Return 4 fwrite failed
+ */
+int store_data(Tox *m, char *path)
+{
+    if (arg_opts.ignore_data_file)
+        return 0;
+
+    if (path == NULL)
+        return 1;
+
+    FILE *fd;
+    size_t len;
+    uint8_t *buf;
+
+    len = tox_size(m);
+    buf = malloc(len);
+
+    if (buf == NULL)
+        return 2;
+
+    tox_save(m, buf);
+
+    fd = fopen(path, "wb");
+
+    if (fd == NULL) {
+        free(buf);
+        return 3;
+    }
+
+    if (fwrite(buf, len, 1, fd) != 1) {
+        free(buf);
+        fclose(fd);
+        return 4;
+    }
+
+    free(buf);
+    fclose(fd);
+    return 0;
+}
+
+static void load_data(Tox *m, char *path)
+{
+    if (arg_opts.ignore_data_file)
+        return;
+
+    FILE *fd;
+    size_t len;
+    uint8_t *buf;
+
+    if ((fd = fopen(path, "rb")) != NULL) {
+        fseek(fd, 0, SEEK_END);
+        len = ftell(fd);
+        fseek(fd, 0, SEEK_SET);
+
+        buf = malloc(len);
+
+        if (buf == NULL) {
+            fclose(fd);
+            exit_toxic_err("failed in load_data", FATALERR_MEMORY);
+        }
+
+        if (fread(buf, len, 1, fd) != 1) {
+            free(buf);
+            fclose(fd);
+            exit_toxic_err("failed in load_data", FATALERR_FREAD);
+        }
+
+        tox_load(m, buf, len);
+        load_friendlist(m);
+
+        free(buf);
+        fclose(fd);
+    } else {
+        int st;
+
+        if ((st = store_data(m, path)) != 0)
+            exit_toxic_err("failed in load_data", FATALERR_STORE_DATA);
+    }
+}
+
+static void do_toxic(Tox *m, ToxWindow *prompt)
+{
+    pthread_mutex_lock(&Winthread.lock);
+
+    do_connection(m, prompt);
+    do_file_senders(m);
+    tox_do(m);    /* main tox-core loop */
+
+    pthread_mutex_unlock(&Winthread.lock);
+}
+
+void *thread_winref(void *data)
+{
+    Tox *m = (Tox *) data;
+
+    while (true) {
+        draw_active_window(m);
+        refresh_inactive_windows();
+    }
+}
+
+static void print_usage(void)
+{
+    fprintf(stderr, "usage: toxic [OPTION] [FILE ...]\n");
+    fprintf(stderr, "  -f, --file           Use specified data file\n");
+    fprintf(stderr, "  -x, --nodata         Ignore data file\n");
+    fprintf(stderr, "  -4, --ipv4           Force IPv4 connection\n");
+    fprintf(stderr, "  -c, --config         Use specified config file\n");
+    fprintf(stderr, "  -n, --nodes          Use specified DHTnodes file\n");
+    fprintf(stderr, "  -h, --help           Show this message and exit\n");
+}
+
+static void set_default_opts(void)
+{
+    arg_opts.use_ipv4 = 0;
+    arg_opts.ignore_data_file = 0;
+}
+
+static void parse_args(int argc, char *argv[])
+{
+    set_default_opts();
+
+    static struct option long_opts[] = {
+        {"file", required_argument, 0, 'f'},
+        {"nodata", no_argument, 0, 'x'},
+        {"ipv4", no_argument, 0, '4'},
+        {"config", required_argument, 0, 'c'},
+        {"nodes", required_argument, 0, 'n'},
+        {"help", no_argument, 0, 'h'},
+    };
+
+    const char *opts_str = "4xf:c:n:h";
+    int opt, indexptr;
+
+    while ((opt = getopt_long(argc, argv, opts_str, long_opts, &indexptr)) != -1) {
+        switch (opt) {
+            case 'f':
+                DATA_FILE = strdup(optarg);
+                break;
+
+            case 'x':
+                arg_opts.ignore_data_file = 1;
+                break;
+
+            case '4':
+                arg_opts.use_ipv4 = 1;
+                break;
+
+            case 'c':
+                snprintf(arg_opts.config_path, sizeof(arg_opts.config_path), "%s", optarg);
+                break;
+
+            case 'n':
+                snprintf(arg_opts.nodes_path, sizeof(arg_opts.nodes_path), "%s", optarg);
+                break;
+
+            case 'h':
+            default:
+                print_usage();
+                exit(EXIT_SUCCESS);
+        }
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    char *user_config_dir = get_user_config_dir();
+    int config_err = 0;
+
+    parse_args(argc, argv);
+
+    /* Make sure all written files are read/writeable only by the current user. */
+    umask(S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+
+    signal(SIGINT, ignore_SIGINT);
+
+    config_err = create_user_config_dir(user_config_dir);
+
+    if (DATA_FILE == NULL ) {
+        if (config_err) {
+            DATA_FILE = strdup("data");
+        } else {
+            DATA_FILE = malloc(strlen(user_config_dir) + strlen(CONFIGDIR) + strlen("data") + 1);
+
+            if (DATA_FILE == NULL)
+                exit_toxic_err("failed in main", FATALERR_MEMORY);
+
+            strcpy(DATA_FILE, user_config_dir);
+            strcat(DATA_FILE, CONFIGDIR);
+            strcat(DATA_FILE, "data");
+        }
+    }
+
+    free(user_config_dir);
+
+    /* init user_settings struct and load settings from conf file */
+    user_settings = malloc(sizeof(struct user_settings));
+
+    if (user_settings == NULL)
+        exit_toxic_err("failed in main", FATALERR_MEMORY);
+
+    memset(user_settings, 0, sizeof(struct user_settings));
+
+    char *p = arg_opts.config_path[0] ? arg_opts.config_path : NULL;
+    int settings_err = settings_load(user_settings, p);
+
+    Tox *m = init_tox(arg_opts.use_ipv4);
+    init_term();
+
+    if (m == NULL)
+        exit_toxic_err("failed in main", FATALERR_NETWORKINIT);
+
+    if (!arg_opts.ignore_data_file)
+        load_data(m, DATA_FILE);
+
+    prompt = init_windows(m);
+
+    /* create new thread for ncurses stuff */
+    if (pthread_mutex_init(&Winthread.lock, NULL) != 0)
+        exit_toxic_err("failed in main", FATALERR_MUTEX_INIT);
+
+    if (pthread_create(&Winthread.tid, NULL, thread_winref, (void *) m) != 0)
+        exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);
+        
+
+    uint8_t *msg;
+
+#ifdef _SUPPORT_AUDIO
+
+    av = init_audio(prompt, m);
+    
+    device_set(prompt, input, user_settings->audio_in_dev);
+    device_set(prompt, output, user_settings->audio_out_dev);
+
+    if ( errors() == NoError )
+        msg = "Audio initiated with no problems.";
+    else /* Get error code and stuff */
+        msg = "Error initiating audio!";
+
+    line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+
+#endif /* _SUPPORT_AUDIO */
+
+    if (config_err) {
+        msg = "Unable to determine configuration directory. Defaulting to 'data' for a keyfile...";
+        line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+    }
+
+
+    if (settings_err == -1) {
+        msg = "Failed to load user settings";
+        line_info_add(prompt, NULL, NULL, NULL, msg, SYS_MSG, 0, 0);
+    }
+
+
+    sort_friendlist_index();
+    prompt_init_statusbar(prompt, m);
+
+    while (true) {
+        update_unix_time();
+        do_toxic(m, prompt);
+        usleep(10000);
+    }
+
+    return 0;
+}

src/toxic.h

@@ -0,0 +1,99 @@
+/*  toxic.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _toxic_h
+#define _toxic_h
+
+#ifndef TOXICVER
+#define TOXICVER "NOVER_"    /* Use the -D flag to set this */
+#endif
+
+#include <stdbool.h>
+#include <curses.h>
+
+#include <tox/tox.h>
+
+#define UNKNOWN_NAME "Anonymous"
+
+#define MAX_FRIENDS_NUM 500
+#define MAX_STR_SIZE 256
+#define MAX_CMDNAME_SIZE 64
+#define TOXIC_MAX_NAME_LENGTH 32   /* Must be <= TOX_MAX_NAME_LENGTH */
+#define KEY_IDENT_DIGITS 2    /* number of hex digits to display for the pub-key based identifier */
+#define TIME_STR_SIZE 16
+
+/* ASCII key codes */
+#define T_KEY_KILL       0x0B     /* ctrl-k */
+#define T_KEY_DISCARD    0x15     /* ctrl-u */
+#define T_KEY_NEXT       0x10     /* ctrl-p */
+#define T_KEY_PREV       0x0F     /* ctrl-o */
+#define T_KEY_C_E        0x05     /* ctrl-e */
+#define T_KEY_C_A        0x01     /* ctrl-a */
+#define T_KEY_C_RB       0x1D     /* ctrl-] */
+#define T_KEY_C_LB       0x1B     /* ctrl-[ */
+#define T_KEY_C_B        0x02     /* ctrl-b */
+#define T_KEY_C_H        0x08     /* ctrl-h */
+
+enum {
+    MOVE_UP,
+    MOVE_DOWN,
+} KEY_DIRS;
+
+typedef enum _FATAL_ERRS {
+    FATALERR_MEMORY = -1,    /* malloc() or calloc() failed */
+    FATALERR_FREAD = -2,     /* fread() failed on critical read */
+    FATALERR_THREAD_CREATE = -3,
+    FATALERR_MUTEX_INIT = -4,
+    FATALERR_LOCALE_SET = -5,
+    FATALERR_STORE_DATA = -6,
+    FATALERR_NETWORKINIT = -7,   /* Tox network failed to init */
+    FATALERR_INFLOOP = -8,       /* infinite loop detected */
+    FATALERR_WININIT = -9,       /* window init failed */
+} FATAL_ERRS;
+
+/* Fixes text color problem on some terminals.
+   Uncomment if necessary */
+/* #define URXVT_FIX */
+
+void exit_toxic_success(Tox *m);
+void exit_toxic_err(const char *errmsg, int errcode);
+
+void on_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata);
+void on_connectionchange(Tox *m, int32_t friendnumber, uint8_t status, void *userdata);
+void on_message(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata);
+void on_action(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata);
+void on_nickchange(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata);
+void on_statuschange(Tox *m, int32_t friendnumber, uint8_t status, void *userdata);
+void on_statusmessagechange(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata);
+void on_friendadded(Tox *m, int32_t friendnumber, bool sort);
+void on_groupmessage(Tox *m, int groupnumber, int peernumber, uint8_t *message, uint16_t length, void *userdata);
+void on_groupaction(Tox *m, int groupnumber, int peernumber, uint8_t *action, uint16_t length, void *userdata);
+void on_groupinvite(Tox *m, int32_t friendnumber, uint8_t *group_pub_key, void *userdata);
+void on_group_namelistchange(Tox *m, int groupnumber, int peernumber, uint8_t change, void *userdata);
+void on_file_sendrequest(Tox *m, int32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *pathname,
+                         uint16_t pathname_length, void *userdata);
+void on_file_control(Tox *m, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber, uint8_t control_type,
+                     uint8_t *data, uint16_t length, void *userdata);
+void on_file_data(Tox *m, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata);
+void on_typing_change(Tox *m, int32_t friendnumber, uint8_t is_typing, void *userdata);
+
+#endif  /* #define _toxic_h */

src/toxic_strings.c

@@ -1,180 +1,225 @@
-/*
- * Toxic -- Tox Curses Client
+/*  toxic_strings.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 
-#include "toxic_windows.h"
+#include "toxic.h"
+#include "windows.h"
 #include "misc_tools.h"
 #include "toxic_strings.h"
 
-/* Adds char to buffer at pos */
-void add_char_to_buf(wchar_t *buf, size_t *pos, size_t *len, wint_t ch)
+/* Adds char to line at pos */
+void add_char_to_buf(ChatContext *ctx, wint_t ch)
 {
-    if (*pos < 0 || *len >= MAX_STR_SIZE)
+    if (ctx->pos < 0 || ctx->len >= MAX_STR_SIZE)
         return;
 
     /* move all chars including null in front of pos one space forward and insert char in pos */
     int i;
 
-    for (i = *len; i >= *pos && i >= 0; --i)
-        buf[i+1] = buf[i];
+    for (i = ctx->len; i >= ctx->pos && i >= 0; --i)
+        ctx->line[i + 1] = ctx->line[i];
 
-    buf[(*pos)++] = ch;
-    ++(*len);
+    ctx->line[ctx->pos++] = ch;
+    ++ctx->len;
 }
 
 /* Deletes the character before pos */
-void del_char_buf_bck(wchar_t *buf, size_t *pos, size_t *len)
+void del_char_buf_bck(ChatContext *ctx)
 {
-    if (*pos <= 0)
+    if (ctx->pos <= 0)
         return;
 
     int i;
 
     /* similar to add_char_to_buf but deletes a char */
-    for (i = *pos-1; i <= *len; ++i)
-        buf[i] = buf[i+1];
+    for (i = ctx->pos - 1; i <= ctx->len; ++i)
+        ctx->line[i] = ctx->line[i + 1];
 
-    --(*pos);
-    --(*len);
+    --ctx->pos;
+    --ctx->len;
 }
 
 /* Deletes the character at pos */
-void del_char_buf_frnt(wchar_t *buf, size_t *pos, size_t *len)
+void del_char_buf_frnt(ChatContext *ctx)
 {
-    if (*pos < 0 || *pos >= *len)
+    if (ctx->pos < 0 || ctx->pos >= ctx->len)
         return;
 
     int i;
 
-    for (i = *pos; i < *len; ++i)
-        buf[i] = buf[i+1];
+    for (i = ctx->pos; i < ctx->len; ++i)
+        ctx->line[i] = ctx->line[i + 1];
 
-    --(*len);
+    --ctx->len;
 }
 
 /* Deletes the line from beginning to pos */
-void discard_buf(wchar_t *buf, size_t *pos, size_t *len)
+void discard_buf(ChatContext *ctx)
 {
-    if (*pos <= 0)
+    if (ctx->pos <= 0)
         return;
 
     int i;
     int c = 0;
 
-    for (i = *pos; i <= *len; ++i)
-        buf[c++] = buf[i];
+    for (i = ctx->pos; i <= ctx->len; ++i)
+        ctx->line[c++] = ctx->line[i];
 
-    *pos = 0;
-    *len = c - 1;
+    ctx->pos = 0;
+    ctx->len = c - 1;
 }
 
 /* Deletes the line from pos to len */
-void kill_buf(wchar_t *buf, size_t *pos, size_t *len)
+void kill_buf(ChatContext *ctx)
 {
-    if (*len == *pos)
+    if (ctx->len == ctx->pos)
         return;
 
-    buf[*pos] = L'\0';
-    *len = *pos;
+    ctx->line[ctx->pos] = L'\0';
+    ctx->len = ctx->pos;
 }
 
-/* nulls buf and sets pos and len to 0 */
-void reset_buf(wchar_t *buf, size_t *pos, size_t *len)
+/* nulls line and sets pos and len to 0 */
+void reset_buf(ChatContext *ctx)
 {
-    buf[0] = L'\0';
-    *pos = 0;
-    *len = 0;
+    ctx->line[0] = L'\0';
+    ctx->pos = 0;
+    ctx->len = 0;
+}
+
+/* Removes trailing spaces from line. */
+void rm_trailing_spaces_buf(ChatContext *ctx)
+{
+    if (ctx->len <= 0)
+        return;
+
+    if (ctx->line[ctx->len - 1] != ' ')
+        return;
+
+    int i;
+
+    for (i = ctx->len - 1; i >= 0; --i) {
+        if (ctx->line[i] != ' ')
+            break;
+    }
+
+    ctx->len = i + 1;
+    ctx->pos = MIN(ctx->pos, ctx->len);
+    ctx->line[ctx->len] = L'\0';
 }
 
 #define HIST_PURGE MAX_LINE_HIST / 4
 
 /* shifts hist items back and makes room for HIST_PURGE new entries */
-static void shift_hist_back(wchar_t (*hst)[MAX_STR_SIZE], int *hst_tot)
+static void shift_hist_back(ChatContext *ctx)
 {
     int i;
     int n = MAX_LINE_HIST - HIST_PURGE;
 
     for (i = 0; i < n; ++i)
-        wmemcpy(hst[i], hst[i+HIST_PURGE], MAX_STR_SIZE);
+        wmemcpy(ctx->ln_history[i], ctx->ln_history[i + HIST_PURGE], MAX_STR_SIZE);
 
-    *hst_tot = n;
+    ctx->hst_tot = n;
 }
 
 /* adds a line to the ln_history buffer at hst_pos and sets hst_pos to end of history. */
-void add_line_to_hist(const wchar_t *buf, size_t len, wchar_t (*hst)[MAX_STR_SIZE], int *hst_tot, 
-                      int *hst_pos)
+void add_line_to_hist(ChatContext *ctx)
 {
-    if (len > MAX_STR_SIZE)
+    if (ctx->len > MAX_STR_SIZE)
         return;
 
-    if (*hst_tot >= MAX_LINE_HIST)
-        shift_hist_back(hst, hst_tot);
+    if (ctx->hst_tot >= MAX_LINE_HIST)
+        shift_hist_back(ctx);
 
-    ++(*hst_tot);
-    *hst_pos = *hst_tot;
+    ++ctx->hst_tot;
+    ctx->hst_pos = ctx->hst_tot;
 
-    wmemcpy(hst[*hst_tot-1], buf, len + 1);
+    wmemcpy(ctx->ln_history[ctx->hst_tot - 1], ctx->line, ctx->len + 1);
 }
 
-/* copies history item at hst_pos to buf. Sets pos and len to the len of the history item.
-   hst_pos is decremented or incremented depending on key_dir. */
-void fetch_hist_item(wchar_t *buf, size_t *pos, size_t *len, wchar_t (*hst)[MAX_STR_SIZE],
-                     int hst_tot, int *hst_pos, int key_dir)
+/* copies history item at hst_pos to line. Sets pos and len to the len of the history item.
+   hst_pos is decremented or incremented depending on key_dir.
+
+   resets line if at end of history */
+void fetch_hist_item(ChatContext *ctx, int key_dir)
 {
-    if (key_dir == LN_HIST_MV_UP) {
-        if (--(*hst_pos) < 0) {
-            ++(*hst_pos);
+    if (key_dir == MOVE_UP) {
+        if (--ctx->hst_pos < 0) {
+            ctx->hst_pos = 0;
             beep();
         }
     } else {
-        if (++(*hst_pos) >= hst_tot) {
-            --(*hst_pos);
-            beep();
+        if (++ctx->hst_pos >= ctx->hst_tot) {
+            ctx->hst_pos = ctx->hst_tot;
+            reset_buf(ctx);
             return;
         }
     }
 
-    const wchar_t *hst_line = hst[*hst_pos];
+    const wchar_t *hst_line = ctx->ln_history[ctx->hst_pos];
     size_t h_len = wcslen(hst_line);
 
-    wmemcpy(buf, hst_line, h_len + 1);
-
-    *pos = h_len;
-    *len = h_len;
+    wmemcpy(ctx->line, hst_line, h_len + 1);
+    ctx->pos = h_len;
+    ctx->len = h_len;
 }
 
-/* looks for the first instance in list that begins with the last entered word in buf according to pos, 
-   then fills buf with the complete word. e.g. "Hello jo" would complete the buffer 
+/* looks for the first instance in list that begins with the last entered word in line according to pos,
+   then fills line with the complete word. e.g. "Hello jo" would complete the line
    with "Hello john".
 
    list is a pointer to the list of strings being compared, n_items is the number of items
    in the list, and size is the size of each item in the list.
 
-   Returns the difference between the old len and new len of buf on success, -1 if error */
-int complete_line(wchar_t *buf, size_t *pos, size_t *len, const void *list, int n_items, int size)
+   Returns the difference between the old len and new len of line on success, -1 if error */
+int complete_line(ChatContext *ctx, const void *list, int n_items, int size)
 {
-    if (*pos <= 0 || *len <= 0 || *len >= MAX_STR_SIZE)
+    if (ctx->pos <= 0 || ctx->len <= 0 || ctx->len >= MAX_STR_SIZE)
         return -1;
 
     const uint8_t *L = (uint8_t *) list;
 
     uint8_t ubuf[MAX_STR_SIZE];
+
     /* work with multibyte string copy of buf for simplicity */
-    if (wcs_to_mbs_buf(ubuf, buf, MAX_STR_SIZE) == -1)
+    if (wcs_to_mbs_buf(ubuf, ctx->line, MAX_STR_SIZE) == -1)
         return -1;
 
     /* isolate substring from space behind pos to pos */
     uint8_t tmp[MAX_STR_SIZE];
     snprintf(tmp, sizeof(tmp), "%s", ubuf);
-    tmp[*pos] = '\0';
+    tmp[ctx->pos] = '\0';
     uint8_t *sub = strrchr(tmp, ' ');
     int n_endchrs = 1;    /* 1 = append space to end of match, 2 = append ": " */
 
     if (!sub++) {
         sub = tmp;
+
         if (sub[0] != '/')    /* make sure it's not a command */
             n_endchrs = 2;
     }
@@ -189,7 +234,8 @@ int complete_line(wchar_t *buf, size_t *pos, size_t *len, const void *list, int
 
     /* look for a match in list */
     for (i = 0; i < n_items; ++i) {
-        match = &L[i*size];
+        match = &L[i * size];
+
         if (is_match = strncasecmp(match, sub, s_len) == 0)
             break;
     }
@@ -200,17 +246,17 @@ int complete_line(wchar_t *buf, size_t *pos, size_t *len, const void *list, int
     /* put match in correct spot in buf and append endchars (space or ": ") */
     const uint8_t *endchrs = n_endchrs == 1 ? " " : ": ";
     int m_len = strlen(match);
-    int strt = (int) *pos - s_len;
+    int strt = ctx->pos - s_len;
     int diff = m_len - s_len + n_endchrs;
 
-    if (*len + diff > MAX_STR_SIZE)
+    if (ctx->len + diff > MAX_STR_SIZE)
         return -1;
 
     uint8_t tmpend[MAX_STR_SIZE];
-    strcpy(tmpend, &ubuf[*pos]);
+    strcpy(tmpend, &ubuf[ctx->pos]);
     strcpy(&ubuf[strt], match);
-    strcpy(&ubuf[strt+m_len], endchrs);
-    strcpy(&ubuf[strt+m_len+n_endchrs], tmpend);
+    strcpy(&ubuf[strt + m_len], endchrs);
+    strcpy(&ubuf[strt + m_len + n_endchrs], tmpend);
 
     /* convert to widechar and copy back to original buf */
     wchar_t newbuf[MAX_STR_SIZE];
@@ -218,10 +264,10 @@ int complete_line(wchar_t *buf, size_t *pos, size_t *len, const void *list, int
     if (mbs_to_wcs_buf(newbuf, ubuf, MAX_STR_SIZE) == -1)
         return -1;
 
-    wcscpy(buf, newbuf);
+    wcscpy(ctx->line, newbuf);
 
-    *len += (size_t) diff;
-    *pos += (size_t) diff;
+    ctx->len += (size_t) diff;
+    ctx->pos += (size_t) diff;
 
     return diff;
 }

src/toxic_strings.h

@@ -1,45 +1,68 @@
-/*
- * Toxic -- Tox Curses Client
+/*  toxic_strings.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
  */
 
-/* Adds char to buffer at pos */
-void add_char_to_buf(wchar_t *buf, size_t *pos, size_t *len, wint_t ch);
+#ifndef _toxic_strings_h
+#define _toxic_strings_h
+
+#include "windows.h"
+
+/* Adds char to line at pos */
+void add_char_to_buf(ChatContext *ctx, wint_t ch);
 
 /* Deletes the character before pos */
-void del_char_buf_bck(wchar_t *buf, size_t *pos, size_t *len);
+void del_char_buf_bck(ChatContext *ctx);
 
 /* Deletes the character at pos */
-void del_char_buf_frnt(wchar_t *buf, size_t *pos, size_t *len);
+void del_char_buf_frnt(ChatContext *ctx);
 
 /* Deletes the line from beginning to pos */
-void discard_buf(wchar_t *buf, size_t *pos, size_t *len);
+void discard_buf(ChatContext *ctx);
 
 /* Deletes the line from pos to len */
-void kill_buf(wchar_t *buf, size_t *pos, size_t *len);
+void kill_buf(ChatContext *ctx);
 
-/* nulls buf and sets pos and len to 0 */
-void reset_buf(wchar_t *buf, size_t *pos, size_t *len);
+/* nulls line and sets pos and len to 0 */
+void reset_buf(ChatContext *ctx);
 
-/* looks for the first instance in list that begins with the last entered word in buf according to pos, 
-   then fills buf with the complete word. e.g. "Hello jo" would complete the buffer 
+/* Removes trailing spaces from line. */
+void rm_trailing_spaces_buf(ChatContext *ctx);
+
+/* looks for the first instance in list that begins with the last entered word in line according to pos,
+   then fills line with the complete word. e.g. "Hello jo" would complete the line
    with "Hello john".
 
    list is a pointer to the list of strings being compared, n_items is the number of items
    in the list, and size is the size of each item in the list.
 
-   Returns the difference between the old len and new len of buf on success, -1 if error */
-int complete_line(wchar_t *buf, size_t *pos, size_t *len, const void *list, int n_items, int size);
-
-enum {
-    LN_HIST_MV_UP,
-    LN_HIST_MV_DWN,
-};
+   Returns the difference between the old len and new len of line on success, -1 if error */
+int complete_line(ChatContext *ctx, const void *list, int n_items, int size);
 
 /* adds a line to the ln_history buffer at hst_pos and sets hst_pos to last history item. */
-void add_line_to_hist(const wchar_t *buf, size_t len, wchar_t (*hst)[MAX_STR_SIZE], int *hst_tot, 
-                      int *hst_pos);
+void add_line_to_hist(ChatContext *ctx);
 
-/* copies history item at hst_pos to buf. Sets pos and len to the len of the history item.
-   hst_pos is decremented or incremented depending on key_dir. */
-void fetch_hist_item(wchar_t *buf, size_t *pos, size_t *len, wchar_t (*hst)[MAX_STR_SIZE],
-                     int hst_tot, int *hst_pos, int key_dir);
+/* copies history item at hst_pos to line. Sets pos and len to the len of the history item.
+   hst_pos is decremented or incremented depending on key_dir.
+
+   resets line if at end of history */
+void fetch_hist_item(ChatContext *ctx, int key_dir);
+
+#endif /* #define _toxic_strings_h */

src/toxic_windows.h

@@ -1,195 +0,0 @@
-/*
- * Toxic -- Tox Curses Client
- */
-
-#ifndef _windows_h
-#define _windows_h
-
-#ifndef TOXICVER
-#define TOXICVER "NOVER_"    /* Use the -D flag to set this */
-#endif
-
-#include <curses.h>
-#include <wctype.h>
-#include <wchar.h>
-
-#include <tox/tox.h>
-
-#define UNKNOWN_NAME "Unknown"
-
-#define MAX_WINDOWS_NUM 32
-#define MAX_FRIENDS_NUM 100
-#define MAX_STR_SIZE 256
-#define MAX_CMDNAME_SIZE 64
-#define KEY_SIZE_BYTES 32
-#define TOXIC_MAX_NAME_LENGTH 32   /* Must be <= TOX_MAX_NAME_LENGTH */
-#define N_DEFAULT_WINS 2    /* number of permanent default windows */
-#define CURS_Y_OFFSET 3    /* y-axis cursor offset for chat contexts */
-#define CHATBOX_HEIGHT 4
-#define KEY_IDENT_DIGITS 2    /* number of hex digits to display for the pub-key based identifier */
-
-#define EXIT_SUCCESS 0
-#define EXIT_FAILURE 1
-
-/* ASCII key codes */
-#define T_KEY_KILL       0xB      /* ctrl-k */
-#define T_KEY_DISCARD    0x15     /* ctrl-u */
-#define T_KEY_NEXT       0x10     /* ctrl-p */
-#define T_KEY_PREV       0x0F     /* ctrl-o */
-
-/* Curses foreground colours (background is black) */
-enum {
-    WHITE,
-    GREEN,
-    CYAN,
-    RED,
-    BLUE,
-    YELLOW,
-    MAGENTA,
-    BLACK,
-};
-
-/* tab alert types: lower types take priority */
-enum {
-    WINDOW_ALERT_0,
-    WINDOW_ALERT_1,
-    WINDOW_ALERT_2,
-};
-
-/* Fixes text color problem on some terminals. 
-   Uncomment if necessary */
-//#define URXVT_FIX
-
-typedef struct ToxWindow ToxWindow;
-typedef struct StatusBar StatusBar;
-typedef struct PromptBuf PromptBuf;
-typedef struct ChatContext ChatContext;
-
-struct ToxWindow {
-    void(*onKey)(ToxWindow *, Tox *, wint_t);
-    void(*onDraw)(ToxWindow *, Tox *);
-    void(*onInit)(ToxWindow *, Tox *);
-    void(*onFriendRequest)(ToxWindow *, uint8_t *, uint8_t *, uint16_t);
-    void(*onFriendAdded)(ToxWindow *, Tox *, int, bool);
-    void(*onConnectionChange)(ToxWindow *, Tox *, int, uint8_t);
-    void(*onMessage)(ToxWindow *, Tox *, int, uint8_t *, uint16_t);
-    void(*onNickChange)(ToxWindow *, Tox *, int, uint8_t *, uint16_t);
-    void(*onStatusChange)(ToxWindow *, Tox *, int, TOX_USERSTATUS);
-    void(*onStatusMessageChange)(ToxWindow *, int, uint8_t *, uint16_t);
-    void(*onAction)(ToxWindow *, Tox *, int, uint8_t *, uint16_t);
-    void(*onGroupMessage)(ToxWindow *, Tox *, int, int, uint8_t *, uint16_t);
-    void(*onGroupAction)(ToxWindow *, Tox *, int, int, uint8_t *, uint16_t);
-    void(*onGroupInvite)(ToxWindow *, Tox *, int, uint8_t *);
-    void(*onGroupNamelistChange)(ToxWindow *, Tox*, int, int, uint8_t);
-    void(*onFileSendRequest)(ToxWindow *, Tox *, int, uint8_t, uint64_t, uint8_t *, uint16_t);
-    void(*onFileControl)(ToxWindow *, Tox *, int, uint8_t, uint8_t, uint8_t, uint8_t *, uint16_t);
-    void(*onFileData)(ToxWindow *, Tox *, int, uint8_t, uint8_t *, uint16_t);
-
-    char name[TOX_MAX_NAME_LENGTH];
-    int num;
-    bool active;
-    int x;
-
-    bool alert0;
-    bool alert1;
-    bool alert2;
-
-    ChatContext *chatwin;
-    PromptBuf *promptbuf;
-    StatusBar *stb;
-
-    WINDOW *window;
-};
-
-/* statusbar info holder */
-struct StatusBar {
-    WINDOW *topline;    
-    uint8_t statusmsg[TOX_MAX_STATUSMESSAGE_LENGTH];
-    uint16_t statusmsg_len;
-    uint8_t nick[TOX_MAX_NAME_LENGTH];
-    uint16_t nick_len;
-    TOX_USERSTATUS status;
-    bool is_online;
-};
-
-#define MAX_LINE_HIST 128
-
-/* chat and groupchat window/buffer holder */
-struct ChatContext {
-    wchar_t line[MAX_STR_SIZE];
-    size_t pos;
-    size_t len;
-
-    wchar_t ln_history[MAX_LINE_HIST][MAX_STR_SIZE];
-    int hst_pos;
-    int hst_tot;
-
-    WINDOW *history;
-    WINDOW *linewin;
-    WINDOW *sidebar;
-};
-
-/* prompt window/buffer holder */
-struct PromptBuf {
-    wchar_t line[MAX_STR_SIZE];
-    size_t pos;
-    size_t len;
-    bool at_bottom;    /* true if line end is at bottom of window */
-    int orig_y;        /* y axis point of line origin */
-    bool scroll;       /* used for prompt window hack to determine when to scroll down */
-
-    wchar_t ln_history[MAX_LINE_HIST][MAX_STR_SIZE];
-    int hst_pos;
-    int hst_tot;
-
-    WINDOW *linewin;
-};
-
-/* Start file transfer code */
-
-#define MAX_FILES 256
-#define FILE_PIECE_SIZE 1024
-#define TIMEOUT_FILESENDER 300
-
-typedef struct {
-    FILE *file;
-    ToxWindow *toxwin;
-    int friendnum;
-    bool active;
-    uint8_t filenum;
-    uint8_t nextpiece[FILE_PIECE_SIZE];
-    uint16_t piecelen;
-    uint8_t pathname[MAX_STR_SIZE];
-    uint64_t timestamp;
-} FileSender;
-
-struct FileReceiver {
-    uint8_t filenames[MAX_FILES][MAX_STR_SIZE];
-    bool pending[MAX_FILES];
-};
-
-/* End file transfer code */
-
-void on_request(uint8_t *public_key, uint8_t *data, uint16_t length, void *userdata);
-void on_connectionchange(Tox *m, int friendnumber, uint8_t status, void *userdata);
-void on_message(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata);
-void on_action(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata);
-void on_nickchange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata);
-void on_statuschange(Tox *m, int friendnumber, TOX_USERSTATUS status, void *userdata);
-void on_statusmessagechange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata);
-void on_friendadded(Tox *m, int friendnumber, bool sort);
-void on_groupmessage(Tox *m, int groupnumber, int peernumber, uint8_t *message, uint16_t length, void *userdata);
-void on_groupaction(Tox *m, int groupnumber, int peernumber, uint8_t *action, uint16_t length, void *userdata);
-void on_groupinvite(Tox *m, int friendnumber, uint8_t *group_pub_key, void *userdata);
-void on_group_namelistchange(Tox *m, int groupnumber, int peernumber, uint8_t change, void *userdata);
-void on_file_sendrequest(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *pathname, uint16_t pathname_length, void *userdata);
-void on_file_control(Tox *m, int friendnumber, uint8_t receive_send, uint8_t filenumber, uint8_t control_type, uint8_t *data, uint16_t length, void *userdata);
-void on_file_data(Tox *m, int friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata);
-
-ToxWindow *init_windows(Tox *m);
-void draw_active_window(Tox *m);
-int add_window(Tox *m, ToxWindow w);
-void del_window(ToxWindow *w);
-void set_active_window(int ch);
-int num_active_windows(void);
-#endif

src/windows.c

@@ -1,33 +1,60 @@
+/*  windows.c
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <stdlib.h>
 #include <string.h>
+#include <pthread.h>
 
 #include "friendlist.h"
 #include "prompt.h"
-#include "toxic_windows.h"
+#include "toxic.h"
+#include "windows.h"
+#include "groupchat.h"
 
 extern char *DATA_FILE;
-
+extern struct _Winthread Winthread;
 static ToxWindow windows[MAX_WINDOWS_NUM];
 static ToxWindow *active_window;
 
 extern ToxWindow *prompt;
 
+static int num_active_windows;
+
 /* CALLBACKS START */
-void on_request(uint8_t *public_key, uint8_t *data, uint16_t length, void *userdata)
+void on_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
 {
     int i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
         if (windows[i].onFriendRequest != NULL)
-            windows[i].onFriendRequest(&windows[i], public_key, data, length);
+            windows[i].onFriendRequest(&windows[i], m, public_key, data, length);
     }
 }
 
-void on_connectionchange(Tox *m, int friendnumber, uint8_t status, void *userdata)
+void on_connectionchange(Tox *m, int32_t friendnumber, uint8_t status, void *userdata)
 {
     int i;
 
@@ -37,7 +64,17 @@ void on_connectionchange(Tox *m, int friendnumber, uint8_t status, void *userdat
     }
 }
 
-void on_message(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void on_typing_change(Tox *m, int32_t friendnumber, uint8_t is_typing, void *userdata)
+{
+    int i;
+
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].onTypingChange != NULL)
+            windows[i].onTypingChange(&windows[i], m, friendnumber, is_typing);
+    }
+}
+
+void on_message(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata)
 {
     int i;
 
@@ -47,7 +84,7 @@ void on_message(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void
     }
 }
 
-void on_action(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void on_action(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata)
 {
     int i;
 
@@ -57,7 +94,7 @@ void on_action(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void
     }
 }
 
-void on_nickchange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void on_nickchange(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata)
 {
     if (friendnumber < 0 || friendnumber > MAX_FRIENDS_NUM)
         return;
@@ -73,7 +110,7 @@ void on_nickchange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, v
         wprintw(prompt->window, "\nCould not store Tox data\n");
 }
 
-void on_statusmessagechange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void on_statusmessagechange(Tox *m, int32_t friendnumber, uint8_t *string, uint16_t length, void *userdata)
 {
     int i;
 
@@ -83,7 +120,7 @@ void on_statusmessagechange(Tox *m, int friendnumber, uint8_t *string, uint16_t
     }
 }
 
-void on_statuschange(Tox *m, int friendnumber, TOX_USERSTATUS status, void *userdata)
+void on_statuschange(Tox *m, int32_t friendnumber, uint8_t status, void *userdata)
 {
     int i;
 
@@ -93,7 +130,7 @@ void on_statuschange(Tox *m, int friendnumber, TOX_USERSTATUS status, void *user
     }
 }
 
-void on_friendadded(Tox *m, int friendnumber, bool sort)
+void on_friendadded(Tox *m, int32_t friendnumber, bool sort)
 {
     int i;
 
@@ -128,7 +165,7 @@ void on_groupaction(Tox *m, int groupnumber, int peernumber, uint8_t *action, ui
     }
 }
 
-void on_groupinvite(Tox *m, int friendnumber, uint8_t *group_pub_key, void *userdata)
+void on_groupinvite(Tox *m, int32_t friendnumber, uint8_t *group_pub_key, void *userdata)
 {
     int i;
 
@@ -148,7 +185,7 @@ void on_group_namelistchange(Tox *m, int groupnumber, int peernumber, uint8_t ch
     }
 }
 
-void on_file_sendrequest(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, 
+void on_file_sendrequest(Tox *m, int32_t friendnumber, uint8_t filenumber, uint64_t filesize,
                          uint8_t *filename, uint16_t filename_length, void *userdata)
 {
     int i;
@@ -160,7 +197,7 @@ void on_file_sendrequest(Tox *m, int friendnumber, uint8_t filenumber, uint64_t
     }
 }
 
-void on_file_control (Tox *m, int friendnumber, uint8_t receive_send, uint8_t filenumber, 
+void on_file_control (Tox *m, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber,
                       uint8_t control_type, uint8_t *data, uint16_t length, void *userdata)
 {
     int i;
@@ -172,7 +209,7 @@ void on_file_control (Tox *m, int friendnumber, uint8_t receive_send, uint8_t fi
     }
 }
 
-void on_file_data(Tox *m, int friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length,
+void on_file_data(Tox *m, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length,
                   void *userdata)
 {
     int i;
@@ -200,13 +237,18 @@ int add_window(Tox *m, ToxWindow w)
 
         if (w.window == NULL)
             return -1;
+
 #ifdef URXVT_FIX
         /* Fixes text color problem on some terminals. */
         wbkgd(w.window, COLOR_PAIR(6));
 #endif
         windows[i] = w;
+
+        if (w.onInit)
             w.onInit(&w, m);
 
+        ++num_active_windows;
+
         return i;
     }
 
@@ -216,13 +258,14 @@ int add_window(Tox *m, ToxWindow w)
 /* Deletes window w and cleans up */
 void del_window(ToxWindow *w)
 {
-    active_window = windows; // Go to prompt screen
+    active_window = windows; /* Go to prompt screen */
 
     delwin(w->window);
     memset(w, 0, sizeof(ToxWindow));
 
     clear();
     refresh();
+    --num_active_windows;
 }
 
 /* Shows next window when tab or back-tab is pressed */
@@ -241,11 +284,8 @@ void set_next_window(int ch)
         if (active_window->window)
             return;
 
-        if (active_window == inf) {    // infinite loop check
-            endwin();
-            fprintf(stderr, "set_next_window() failed. Aborting...\n");
-            exit(EXIT_FAILURE);
-        }
+        if (active_window == inf)    /* infinite loop check */
+            exit_toxic_err("failed in set_next_window", FATALERR_INFLOOP);
     }
 }
 
@@ -261,11 +301,8 @@ ToxWindow *init_windows(Tox *m)
 {
     int n_prompt = add_window(m, new_prompt());
 
-    if (n_prompt == -1 || add_window(m, new_friendlist()) == -1) {
-        endwin();
-        fprintf(stderr, "add_window() failed. Aborting...\n");
-        exit(EXIT_FAILURE);
-    }
+    if (n_prompt == -1 || add_window(m, new_friendlist()) == -1)
+        exit_toxic_err("failed in init_windows", FATALERR_WININIT);
 
     prompt = &windows[n_prompt];
     active_window = prompt;
@@ -273,6 +310,12 @@ ToxWindow *init_windows(Tox *m)
     return prompt;
 }
 
+void on_window_resize(int sig)
+{
+    refresh();
+    clear();
+}
+
 static void draw_window_tab(ToxWindow toxwin)
 {
     /* alert0 takes priority */
@@ -309,26 +352,29 @@ static void draw_bar(void)
     int i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].active) {
-            if (windows + i == active_window) {
+        if (!windows[i].active)
+            continue;
+
+        if (windows + i == active_window)
+
 #ifdef URXVT_FIX
             attron(A_BOLD | COLOR_PAIR(GREEN));
-            } else {
+        else
 #endif
+
             attron(A_BOLD);
-            }
 
         draw_window_tab(windows[i]);
 
-            if (windows + i == active_window) {
+        if (windows + i == active_window)
+
 #ifdef URXVT_FIX
             attroff(A_BOLD | COLOR_PAIR(GREEN));
-            } else {
+        else
 #endif
+
             attroff(A_BOLD);
     }
-        }
-    }
 
     refresh();
 }
@@ -353,27 +399,65 @@ void draw_active_window(Tox *m)
     wrefresh(a->window);
 
     /* Handle input */
+    bool ltr;
 #ifdef HAVE_WIDECHAR
-    wget_wch(stdscr, &ch);
+    int status = wget_wch(stdscr, &ch);
+
+    if (status == ERR)
+        return;
+
+    if (status == OK)
+        ltr = iswprint(ch);
+    else /* if (status == KEY_CODE_YES) */
+        ltr = false;
+
 #else
     ch = getch();
+
+    if (ch == ERR)
+        return;
+
+    /* TODO verify if this works */
+    ltr = isprint(ch);
 #endif
 
-    if (ch == T_KEY_NEXT || ch == T_KEY_PREV)
+    if (!ltr && (ch == T_KEY_NEXT || ch == T_KEY_PREV)) {
         set_next_window((int) ch);
-    else if (ch != ERR)
-        a->onKey(a, m, ch);
+    } else {
+        pthread_mutex_lock(&Winthread.lock);
+        a->onKey(a, m, ch, ltr);
+        pthread_mutex_unlock(&Winthread.lock);
+    }
 }
 
-int num_active_windows(void)
+/* refresh inactive windows to prevent scrolling bugs. 
+   call at least once per second */
+void refresh_inactive_windows(void)
 {
-    int count = 0;
     int i;
 
     for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].active)
-            ++count;
-    }
+        ToxWindow *a = &windows[i];
 
-    return count;
+        if (a->active && a != active_window && (a->is_chat || a->is_groupchat))
+            line_info_print(a);
+    }
+}
+
+int get_num_active_windows(void)
+{
+    return num_active_windows;
+}
+
+/* destroys all chat and groupchat windows (should only be called on shutdown) */
+void kill_all_windows(void)
+{
+    int i;
+
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].is_chat)
+            kill_chat_window(&windows[i]);
+        else if (windows[i].is_groupchat)
+            kill_groupchat_window(&windows[i]);
+    }
 }

src/windows.h

@@ -0,0 +1,181 @@
+/*  windows.h
+ *
+ *
+ *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Toxic is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _windows_h
+#define _windows_h
+
+#include <pthread.h>
+#include <wctype.h>
+#include <wchar.h>
+
+#include <tox/tox.h>
+
+#ifdef _SUPPORT_AUDIO
+#include <tox/toxav.h>
+#endif /* _SUPPORT_AUDIO */
+
+#include "toxic.h"
+
+#define MAX_WINDOWS_NUM 32
+#define CURS_Y_OFFSET 3    /* y-axis cursor offset for chat contexts */
+#define CHATBOX_HEIGHT 4
+
+/* Curses foreground colours (background is black) */
+enum {
+    WHITE,
+    GREEN,
+    CYAN,
+    RED,
+    BLUE,
+    YELLOW,
+    MAGENTA,
+    BLACK,
+} C_COLOURS;
+
+/* tab alert types: lower types take priority */
+enum {
+    WINDOW_ALERT_0,
+    WINDOW_ALERT_1,
+    WINDOW_ALERT_2,
+} WINDOW_ALERTS;
+
+/* Fixes text color problem on some terminals.
+   Uncomment if necessary */
+/* #define URXVT_FIX */
+
+struct _Winthread {
+    pthread_t tid;
+    pthread_mutex_t lock;
+};
+
+typedef struct ToxWindow ToxWindow;
+typedef struct StatusBar StatusBar;
+typedef struct PromptBuf PromptBuf;
+typedef struct ChatContext ChatContext;
+
+struct ToxWindow {
+    void(*onKey)(ToxWindow *, Tox *, wint_t, bool);
+    void(*onDraw)(ToxWindow *, Tox *);
+    void(*onInit)(ToxWindow *, Tox *);
+    void(*onFriendRequest)(ToxWindow *, Tox *, const uint8_t *, const uint8_t *, uint16_t);
+    void(*onFriendAdded)(ToxWindow *, Tox *, int32_t, bool);
+    void(*onConnectionChange)(ToxWindow *, Tox *, int32_t, uint8_t);
+    void(*onMessage)(ToxWindow *, Tox *, int32_t, uint8_t *, uint16_t);
+    void(*onNickChange)(ToxWindow *, Tox *, int32_t, uint8_t *, uint16_t);
+    void(*onStatusChange)(ToxWindow *, Tox *, int32_t, uint8_t);
+    void(*onStatusMessageChange)(ToxWindow *, int32_t, uint8_t *, uint16_t);
+    void(*onAction)(ToxWindow *, Tox *, int32_t, uint8_t *, uint16_t);
+    void(*onGroupMessage)(ToxWindow *, Tox *, int, int, uint8_t *, uint16_t);
+    void(*onGroupAction)(ToxWindow *, Tox *, int, int, uint8_t *, uint16_t);
+    void(*onGroupInvite)(ToxWindow *, Tox *, int32_t, uint8_t *);
+    void(*onGroupNamelistChange)(ToxWindow *, Tox *, int, int, uint8_t);
+    void(*onFileSendRequest)(ToxWindow *, Tox *, int32_t, uint8_t, uint64_t, uint8_t *, uint16_t);
+    void(*onFileControl)(ToxWindow *, Tox *, int32_t, uint8_t, uint8_t, uint8_t, uint8_t *, uint16_t);
+    void(*onFileData)(ToxWindow *, Tox *, int32_t, uint8_t, uint8_t *, uint16_t);
+    void(*onTypingChange)(ToxWindow *, Tox *, int32_t, uint8_t);
+
+#ifdef _SUPPORT_AUDIO
+
+    void(*onInvite)(ToxWindow *, ToxAv *, int);
+    void(*onRinging)(ToxWindow *, ToxAv *, int);
+    void(*onStarting)(ToxWindow *, ToxAv *, int);
+    void(*onEnding)(ToxWindow *, ToxAv *, int);
+    void(*onError)(ToxWindow *, ToxAv *, int);
+    void(*onStart)(ToxWindow *, ToxAv *, int);
+    void(*onCancel)(ToxWindow *, ToxAv *, int);
+    void(*onReject)(ToxWindow *, ToxAv *, int);
+    void(*onEnd)(ToxWindow *, ToxAv *, int);
+    void(*onRequestTimeout)(ToxWindow *, ToxAv *, int);
+    void(*onPeerTimeout)(ToxWindow *, ToxAv *, int);
+
+    int call_index; /* If in a call will have this index set, otherwise it's -1. 
+                     * Don't modify outside av callbacks. */
+#endif /* _SUPPORT_AUDIO */
+
+    char name[TOX_MAX_NAME_LENGTH];
+    int32_t num;    /* corresponds to friendnumber in chat windows */
+    bool active;
+    int x;
+
+    /* window type identifiers */
+    bool is_chat;
+    bool is_groupchat;
+    bool is_prompt;
+
+    bool alert0;
+    bool alert1;
+    bool alert2;
+
+    ChatContext *chatwin;
+    StatusBar *stb;
+
+    WINDOW *popup;
+    WINDOW *window;
+};
+
+/* statusbar info holder */
+struct StatusBar {
+    WINDOW *topline;
+    uint8_t statusmsg[TOX_MAX_STATUSMESSAGE_LENGTH];
+    uint16_t statusmsg_len;
+    uint8_t nick[TOX_MAX_NAME_LENGTH];
+    uint16_t nick_len;
+    uint8_t status;
+    bool is_online;
+};
+
+#define MAX_LINE_HIST 128
+
+/* chat and groupchat window/buffer holder */
+struct ChatContext {
+    wchar_t line[MAX_STR_SIZE];
+    size_t pos;
+    size_t len;
+
+    wchar_t ln_history[MAX_LINE_HIST][MAX_STR_SIZE];  /* history for input lines/commands */
+    int hst_pos;
+    int hst_tot;
+
+    struct history *hst;
+    struct chatlog *log;
+
+    uint8_t self_is_typing;
+
+    WINDOW *history;
+    WINDOW *linewin;
+    WINDOW *sidebar;
+
+    /* specific for prompt */
+    bool at_bottom;    /* true if line end is at bottom of window */
+    int orig_y;        /* y axis point of line origin */
+};
+
+ToxWindow *init_windows(Tox *m);
+void draw_active_window(Tox *m);
+int add_window(Tox *m, ToxWindow w);
+void del_window(ToxWindow *w);
+void set_active_window(int ch);
+int get_num_active_windows(void);
+void kill_all_windows(void);    /* should only be called on shutdown */
+void on_window_resize(int sig);
+
+#endif  /* #define _windows_h */