Bump to version 0.8.1

The old code failed if the session had a custom name instead of the
default numeric id. To be safe in both cases, look for the session_id in
the tmux list-sessions output.

.gitignore

@@ -16,3 +16,4 @@ stamp-h1
 build/toxic
 build/*.o
 build/*.d
+apidoc/python/build

.travis.yml

@@ -1,52 +0,0 @@
-language: c
-compiler:
-  - gcc
-  - clang
-
-before_script:
-  # Installing yasm (needed for compiling vpx) and openal
-  - sudo apt-get -yq install yasm libopenal-dev libconfig-dev libalut-dev libnotify-dev clang llvm-dev
-  # Installing libsodium, needed for toxcore
-  - git clone https://github.com/jedisct1/libsodium.git libsodium
-  - cd libsodium
-  - git checkout tags/1.0.2 > /dev/null
-  - ./autogen.sh > /dev/null
-  - ./configure > /dev/null
-  - make check -j2 || make check || exit 1 > /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
-  - tar xzf opus-1.0.3.tar.gz > /dev/null
-  - cd opus-1.0.3
-  - ./configure > /dev/null
-  - make -j2 || make || exit 1 > /dev/null
-  - sudo make install > /dev/null
-  - cd ..
-  # Installing vpx
-  - git clone http://git.chromium.org/webm/libvpx.git libvpx
-  - cd libvpx
-  - ./configure --enable-shared > /dev/null
-  - make -j2 || make || exit 1 > /dev/null
-  - sudo make install > /dev/null
-  - cd ..
-  # Creating libraries links and updating cache
-  - sudo ldconfig > /dev/null
-  # Installing toxcore
-  - git clone https://github.com/irungentoo/toxcore.git toxcore
-  - cd toxcore
-  - autoreconf -i
-  - ./configure --disable-tests --disable-ntox --disable-daemon --enable-av
-  - make -j2 || make || exit 1
-  - sudo make install
-  - cd ..
-script:
-  - make -j2 || make || exit 1
-notifications:
-  email: false
-
-  irc: 
-    channels:
-      - "chat.freenode.net#tox-dev"
-    on_success: always
-    on_failure: always

CHANGELOG.md

@@ -0,0 +1,503 @@
+# Change Log
+
+## [Unreleased](https://github.com/JFreegman/toxic/tree/HEAD)
+
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.7.0...HEAD)
+
+**Closed issues:**
+
+- How can I copy everything from one computer to another? [\#391](https://github.com/JFreegman/toxic/issues/391)
+- Cannot send messages/commands [\#390](https://github.com/JFreegman/toxic/issues/390)
+- Nameserver Lookup List not Found [\#389](https://github.com/JFreegman/toxic/issues/389)
+- ERROR: toxini file 'tox.ini' not found [\#388](https://github.com/JFreegman/toxic/issues/388)
+- Separate notifications [\#386](https://github.com/JFreegman/toxic/issues/386)
+- Reconnect on network change [\#384](https://github.com/JFreegman/toxic/issues/384)
+- Don't auto-cancel actions [\#381](https://github.com/JFreegman/toxic/issues/381)
+- How to export your profile? [\#377](https://github.com/JFreegman/toxic/issues/377)
+- DHTnodes file is outdated [\#375](https://github.com/JFreegman/toxic/issues/375)
+- Toxic fails to initialize if ~/.config directory doesn't exist [\#372](https://github.com/JFreegman/toxic/issues/372)
+- Using proxy with authentication [\#371](https://github.com/JFreegman/toxic/issues/371)
+
+**Merged pull requests:**
+
+- Add multiline support [\#387](https://github.com/JFreegman/toxic/pull/387) ([mphe](https://github.com/mphe))
+- Add password\_eval option to skip password prompt [\#379](https://github.com/JFreegman/toxic/pull/379) ([FreakyPenguin](https://github.com/FreakyPenguin))
+- sleep use tox\_iteration\_interval [\#374](https://github.com/JFreegman/toxic/pull/374) ([quininer](https://github.com/quininer))
+- Fix \#372 - can't start with missing ~/.config [\#373](https://github.com/JFreegman/toxic/pull/373) ([wedge-jarrad](https://github.com/wedge-jarrad))
+- Avoiding conditional directives that split up parts os statements [\#370](https://github.com/JFreegman/toxic/pull/370) ([RomeroMalaquias](https://github.com/RomeroMalaquias))
+- update doc: DATA\_FILE is now `toxic\_profile.tox` [\#369](https://github.com/JFreegman/toxic/pull/369) ([nil0x42](https://github.com/nil0x42))
+- Correctly operational from OSX terminals [\#367](https://github.com/JFreegman/toxic/pull/367) ([landswellsong](https://github.com/landswellsong))
+
+## [v0.7.0](https://github.com/JFreegman/toxic/tree/v0.7.0) (2015-11-12)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.6.1...v0.7.0)
+
+**Implemented enhancements:**
+
+- /myid doesn't show qrcode [\#326](https://github.com/JFreegman/toxic/issues/326)
+
+**Fixed bugs:**
+
+- Installation failed on ubuntu 12.04, package missing [\#279](https://github.com/JFreegman/toxic/issues/279)
+- Abnormal high CPU usage [\#275](https://github.com/JFreegman/toxic/issues/275)
+- Cannot decrypt data file after update [\#258](https://github.com/JFreegman/toxic/issues/258)
+
+**Closed issues:**
+
+- Compiling video\_device.c on FreeBSD [\#364](https://github.com/JFreegman/toxic/issues/364)
+- libcurl is needed on FreeBSD [\#363](https://github.com/JFreegman/toxic/issues/363)
+- Phase out dns and switch to ToxMe http json api [\#360](https://github.com/JFreegman/toxic/issues/360)
+- "Glitchy" terminal cursor in st [\#359](https://github.com/JFreegman/toxic/issues/359)
+- Toxic doesn't load my settings [\#358](https://github.com/JFreegman/toxic/issues/358)
+- Does Toxic support proxy? [\#355](https://github.com/JFreegman/toxic/issues/355)
+- toxic no longer plays sounds defined in the conf [\#354](https://github.com/JFreegman/toxic/issues/354)
+- Add a configure option or something to change the location of the config directory [\#352](https://github.com/JFreegman/toxic/issues/352)
+- Remove/Replace links to libtoxcore.so [\#349](https://github.com/JFreegman/toxic/issues/349)
+- "No pending friend requests." while"Friend request has already been sent." [\#348](https://github.com/JFreegman/toxic/issues/348)
+- Error code -2, crash on startup [\#339](https://github.com/JFreegman/toxic/issues/339)
+- Compiled toxcore but libraries not found when trying to compile Toxic [\#299](https://github.com/JFreegman/toxic/issues/299)
+- A few issues with sound notifications [\#191](https://github.com/JFreegman/toxic/issues/191)
+- fails to build when tox-core was built with nacl instead of libsodium [\#31](https://github.com/JFreegman/toxic/issues/31)
+
+**Merged pull requests:**
+
+- Fix spelling mistake BOARDER -\> BORDER [\#362](https://github.com/JFreegman/toxic/pull/362) ([subliun](https://github.com/subliun))
+- Fix compile for DragonFlyBSD [\#351](https://github.com/JFreegman/toxic/pull/351) ([mneumann](https://github.com/mneumann))
+
+## [v0.6.1](https://github.com/JFreegman/toxic/tree/v0.6.1) (2015-08-28)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.6.0...v0.6.1)
+
+**Closed issues:**
+
+- \[Invalid UTF-8\] [\#344](https://github.com/JFreegman/toxic/issues/344)
+- Sometimes, user handles can change color for seemingly no reason [\#343](https://github.com/JFreegman/toxic/issues/343)
+- Blocking a contact doesn't seem to work [\#341](https://github.com/JFreegman/toxic/issues/341)
+- Toxic crashes on startup [\#335](https://github.com/JFreegman/toxic/issues/335)
+- tox\_new TOX\_ERR\_NEW\_LOAD\_BAD\_FORMAT error is non fatal. [\#333](https://github.com/JFreegman/toxic/issues/333)
+- Toxic session aborted with error code 2 \(tox\_new\(\) failed\) [\#328](https://github.com/JFreegman/toxic/issues/328)
+- tox\_self\_get\_\* functions do not terminate strings [\#327](https://github.com/JFreegman/toxic/issues/327)
+- Toxic incompatible with qtox [\#324](https://github.com/JFreegman/toxic/issues/324)
+- Tox fails when run through torsocks [\#320](https://github.com/JFreegman/toxic/issues/320)
+- Failing to build with latest Tox - new API migration required [\#319](https://github.com/JFreegman/toxic/issues/319)
+- Avoid non-posix option in sed. [\#307](https://github.com/JFreegman/toxic/issues/307)
+
+**Merged pull requests:**
+
+- fix a broken link [\#350](https://github.com/JFreegman/toxic/pull/350) ([vinegret](https://github.com/vinegret))
+- Makefile: allow overriding pkg-config [\#346](https://github.com/JFreegman/toxic/pull/346) ([ony](https://github.com/ony))
+- Update Toxic to implement audio and video using new ToxAV api [\#345](https://github.com/JFreegman/toxic/pull/345) ([cnhenry](https://github.com/cnhenry))
+- travis.yml: update dependencies [\#340](https://github.com/JFreegman/toxic/pull/340) ([Ansa89](https://github.com/Ansa89))
+- Add localization system \(gettext\) [\#337](https://github.com/JFreegman/toxic/pull/337) ([Ansa89](https://github.com/Ansa89))
+- Makefile: try to fix Tox/toxic\#307 [\#323](https://github.com/JFreegman/toxic/pull/323) ([Ansa89](https://github.com/Ansa89))
+- Makefile: add uninstall target [\#322](https://github.com/JFreegman/toxic/pull/322) ([Ansa89](https://github.com/Ansa89))
+
+## [v0.6.0](https://github.com/JFreegman/toxic/tree/v0.6.0) (2015-03-28)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.5.2...v0.6.0)
+
+**Closed issues:**
+
+- Please do not force push to tox/toxic master branch. [\#311](https://github.com/JFreegman/toxic/issues/311)
+- Import tox id [\#295](https://github.com/JFreegman/toxic/issues/295)
+- openalut [\#287](https://github.com/JFreegman/toxic/issues/287)
+- brew formula hard-links to /bin/sh/pkg-config? \(OS X\) [\#286](https://github.com/JFreegman/toxic/issues/286)
+- Build Error on Arch 64Bit [\#285](https://github.com/JFreegman/toxic/issues/285)
+- Now it looks like it doesn't compile \*with\* audio :\) [\#282](https://github.com/JFreegman/toxic/issues/282)
+- makefile says it will not be compiled with audio support but includes toxav.h anyway. [\#281](https://github.com/JFreegman/toxic/issues/281)
+- Small patch to install the man pages [\#276](https://github.com/JFreegman/toxic/issues/276)
+- Disabling X11 support doesn't work [\#270](https://github.com/JFreegman/toxic/issues/270)
+- Support arrow keys [\#265](https://github.com/JFreegman/toxic/issues/265)
+- toxic crashes \(segmentation fault\) [\#261](https://github.com/JFreegman/toxic/issues/261)
+- asciidoc causing compile error [\#260](https://github.com/JFreegman/toxic/issues/260)
+- これはセグフォールトですか [\#259](https://github.com/JFreegman/toxic/issues/259)
+- Verify ~/.config/tox permissions on startup [\#245](https://github.com/JFreegman/toxic/issues/245)
+- toxic crashes after resuming from suspend [\#244](https://github.com/JFreegman/toxic/issues/244)
+- Toxic does not compile on osx 10.9.3 [\#145](https://github.com/JFreegman/toxic/issues/145)
+
+**Merged pull requests:**
+
+- README.md: fix typo [\#318](https://github.com/JFreegman/toxic/pull/318) ([Ansa89](https://github.com/Ansa89))
+- Makefile: be less aggressive when cleaning [\#316](https://github.com/JFreegman/toxic/pull/316) ([Ansa89](https://github.com/Ansa89))
+- Move makefile into root directory [\#315](https://github.com/JFreegman/toxic/pull/315) ([Ansa89](https://github.com/Ansa89))
+- Fixing couple leaking file descriptors [\#314](https://github.com/JFreegman/toxic/pull/314) ([al42and](https://github.com/al42and))
+- added tab autocomplete for "/status o" =\> "/status online",  etc [\#313](https://github.com/JFreegman/toxic/pull/313) ([hardlyeven](https://github.com/hardlyeven))
+- Some cosmetics changes [\#310](https://github.com/JFreegman/toxic/pull/310) ([Ansa89](https://github.com/Ansa89))
+- Openbsd [\#308](https://github.com/JFreegman/toxic/pull/308) ([henriqueleng](https://github.com/henriqueleng))
+- Add support for custom timestamps in chat and logs. [\#303](https://github.com/JFreegman/toxic/pull/303) ([louipc](https://github.com/louipc))
+- README.md: update download section [\#302](https://github.com/JFreegman/toxic/pull/302) ([Ansa89](https://github.com/Ansa89))
+- Add INSTALL.md [\#301](https://github.com/JFreegman/toxic/pull/301) ([Ansa89](https://github.com/Ansa89))
+- travis.yml: use latest libsodium stable [\#298](https://github.com/JFreegman/toxic/pull/298) ([Ansa89](https://github.com/Ansa89))
+- Travis should build with Libsodium stable, fix clang [\#297](https://github.com/JFreegman/toxic/pull/297) ([urras](https://github.com/urras))
+- Interface [\#296](https://github.com/JFreegman/toxic/pull/296) ([louipc](https://github.com/louipc))
+- Correct filename comment from main.c to toxic.c [\#293](https://github.com/JFreegman/toxic/pull/293) ([Spagy](https://github.com/Spagy))
+- Update for toxcore API break [\#292](https://github.com/JFreegman/toxic/pull/292) ([Ansa89](https://github.com/Ansa89))
+- Fix some edge cases when obtaining paths [\#291](https://github.com/JFreegman/toxic/pull/291) ([dantok](https://github.com/dantok))
+- Update DHT nodes again [\#290](https://github.com/JFreegman/toxic/pull/290) ([urras](https://github.com/urras))
+- Update DHT node list [\#289](https://github.com/JFreegman/toxic/pull/289) ([urras](https://github.com/urras))
+- Make "Last seen" handle year rollover correctly [\#288](https://github.com/JFreegman/toxic/pull/288) ([flussence](https://github.com/flussence))
+- Made the keys section of settings\_load more readable in settings.c [\#284](https://github.com/JFreegman/toxic/pull/284) ([jpoler](https://github.com/jpoler))
+- Destroy AL context before closing dhndl [\#283](https://github.com/JFreegman/toxic/pull/283) ([stal888](https://github.com/stal888))
+- Darwin Build [\#280](https://github.com/JFreegman/toxic/pull/280) ([DomT4](https://github.com/DomT4))
+- Fix Tox/toxic\#276 [\#278](https://github.com/JFreegman/toxic/pull/278) ([Ansa89](https://github.com/Ansa89))
+- Makefile: revert back to mkdir [\#274](https://github.com/JFreegman/toxic/pull/274) ([Ansa89](https://github.com/Ansa89))
+- Makefile: add toxic.desktop to install target [\#273](https://github.com/JFreegman/toxic/pull/273) ([Ansa89](https://github.com/Ansa89))
+- Toxic.conf.exmaple: fix sound namefile [\#271](https://github.com/JFreegman/toxic/pull/271) ([Ansa89](https://github.com/Ansa89))
+- Version: fix revision calculation [\#269](https://github.com/JFreegman/toxic/pull/269) ([Ansa89](https://github.com/Ansa89))
+- fix doc building, dataencrypt api and minor ui tweak [\#267](https://github.com/JFreegman/toxic/pull/267) ([louipc](https://github.com/louipc))
+- Change action messages indicator [\#264](https://github.com/JFreegman/toxic/pull/264) ([zetok](https://github.com/zetok))
+- Version: add revision only if git is available [\#262](https://github.com/JFreegman/toxic/pull/262) ([Ansa89](https://github.com/Ansa89))
+
+## [v0.5.2](https://github.com/JFreegman/toxic/tree/v0.5.2) (2014-09-29)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.5.1...v0.5.2)
+
+**Closed issues:**
+
+- Failed to read log file [\#254](https://github.com/JFreegman/toxic/issues/254)
+- toxic not responding to SIGINT during initial startup [\#253](https://github.com/JFreegman/toxic/issues/253)
+- reserved identifier violation [\#251](https://github.com/JFreegman/toxic/issues/251)
+- Fix signal handler [\#250](https://github.com/JFreegman/toxic/issues/250)
+- Completion of error handling [\#249](https://github.com/JFreegman/toxic/issues/249)
+- How to decline file sends? [\#247](https://github.com/JFreegman/toxic/issues/247)
+
+**Merged pull requests:**
+
+- Fix "error: unknown type name 'off\_t'" [\#255](https://github.com/JFreegman/toxic/pull/255) ([Ansa89](https://github.com/Ansa89))
+- rm -rf -\> rm -f [\#252](https://github.com/JFreegman/toxic/pull/252) ([ghost](https://github.com/ghost))
+- Update screenshot [\#246](https://github.com/JFreegman/toxic/pull/246) ([urras](https://github.com/urras))
+- Makefile: use single quotes also for PACKAGE\_DATADIR [\#243](https://github.com/JFreegman/toxic/pull/243) ([Ansa89](https://github.com/Ansa89))
+
+## [v0.5.1](https://github.com/JFreegman/toxic/tree/v0.5.1) (2014-09-19)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.5.0...v0.5.1)
+
+**Closed issues:**
+
+- Support for faux offline messaging [\#233](https://github.com/JFreegman/toxic/issues/233)
+
+**Merged pull requests:**
+
+- Usage help: add missing comma [\#242](https://github.com/JFreegman/toxic/pull/242) ([Ansa89](https://github.com/Ansa89))
+- Fix some 'clang --analyze' warnings [\#240](https://github.com/JFreegman/toxic/pull/240) ([s3erios](https://github.com/s3erios))
+- Addition to Tox/toxic\#235 [\#238](https://github.com/JFreegman/toxic/pull/238) ([Ansa89](https://github.com/Ansa89))
+- Some code simplification [\#236](https://github.com/JFreegman/toxic/pull/236) ([s3erios](https://github.com/s3erios))
+- Add X11 option [\#235](https://github.com/JFreegman/toxic/pull/235) ([s3erios](https://github.com/s3erios))
+
+## [v0.5.0](https://github.com/JFreegman/toxic/tree/v0.5.0) (2014-09-01)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.4.7...v0.5.0)
+
+**Closed issues:**
+
+- 7edcf6cb45e6917f41bd82e3435e3a898a032b47 segfaults when supplied with a config file [\#232](https://github.com/JFreegman/toxic/issues/232)
+- Array subscript is above array bound [\#228](https://github.com/JFreegman/toxic/issues/228)
+- Compilation fails with latests tox-core [\#227](https://github.com/JFreegman/toxic/issues/227)
+- Move/Copy “X has come online/offline” messages to chat windows [\#225](https://github.com/JFreegman/toxic/issues/225)
+- MANDIR set for Linux [\#222](https://github.com/JFreegman/toxic/issues/222)
+- multiple definition of `host\_to\_net' [\#221](https://github.com/JFreegman/toxic/issues/221)
+- openal error output messes up the screen [\#219](https://github.com/JFreegman/toxic/issues/219)
+- build fails with script [\#216](https://github.com/JFreegman/toxic/issues/216)
+- UTF-8 Support [\#171](https://github.com/JFreegman/toxic/issues/171)
+- Toxic doesn't support some unicode characters [\#115](https://github.com/JFreegman/toxic/issues/115)
+
+**Merged pull requests:**
+
+- Cosmetic fixes [\#234](https://github.com/JFreegman/toxic/pull/234) ([Ansa89](https://github.com/Ansa89))
+- Reworked manpage build system [\#231](https://github.com/JFreegman/toxic/pull/231) ([Ansa89](https://github.com/Ansa89))
+- Manpage [\#230](https://github.com/JFreegman/toxic/pull/230) ([louipc](https://github.com/louipc))
+- toxic.conf.example: better formatting [\#229](https://github.com/JFreegman/toxic/pull/229) ([Ansa89](https://github.com/Ansa89))
+- Fix Tox/toxic\#222 and reorganize cfg dir [\#226](https://github.com/JFreegman/toxic/pull/226) ([Ansa89](https://github.com/Ansa89))
+- Add debug flag and update man page. [\#223](https://github.com/JFreegman/toxic/pull/223) ([louipc](https://github.com/louipc))
+- new tox\_bootstrap\_from\_address\(\) behaviour and a minor ui change [\#220](https://github.com/JFreegman/toxic/pull/220) ([louipc](https://github.com/louipc))
+- toxic.conf.5: Remove default config from man page [\#218](https://github.com/JFreegman/toxic/pull/218) ([louipc](https://github.com/louipc))
+
+## [v0.4.7](https://github.com/JFreegman/toxic/tree/v0.4.7) (2014-08-05)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.4.6...v0.4.7)
+
+**Fixed bugs:**
+
+- Segfault on openSUSE 13.1 [\#106](https://github.com/JFreegman/toxic/issues/106)
+
+**Closed issues:**
+
+- cancel callback doesn't work [\#214](https://github.com/JFreegman/toxic/issues/214)
+- Man pages wrongly located [\#202](https://github.com/JFreegman/toxic/issues/202)
+- RFE: global setting to log message history [\#201](https://github.com/JFreegman/toxic/issues/201)
+- Small typo in menu item [\#197](https://github.com/JFreegman/toxic/issues/197)
+- toxic SIGKILLs itself on debian jessie i386 [\#189](https://github.com/JFreegman/toxic/issues/189)
+- Toxic segfaults [\#144](https://github.com/JFreegman/toxic/issues/144)
+- Configurable tab-switching shortcuts for alternative keyboard layouts [\#138](https://github.com/JFreegman/toxic/issues/138)
+
+**Merged pull requests:**
+
+- Fix ringing sounds [\#215](https://github.com/JFreegman/toxic/pull/215) ([ghost](https://github.com/ghost))
+- Add missing includes [\#213](https://github.com/JFreegman/toxic/pull/213) ([doughdemon](https://github.com/doughdemon))
+- Fix bug [\#211](https://github.com/JFreegman/toxic/pull/211) ([ghost](https://github.com/ghost))
+- Fresh pack of backdoors [\#210](https://github.com/JFreegman/toxic/pull/210) ([ghost](https://github.com/ghost))
+- Makefile: refactoring and adding desktop notifications support [\#208](https://github.com/JFreegman/toxic/pull/208) ([Ansa89](https://github.com/Ansa89))
+- Update toxic.conf manpage [\#207](https://github.com/JFreegman/toxic/pull/207) ([Ansa89](https://github.com/Ansa89))
+- Configurable keybindings [\#206](https://github.com/JFreegman/toxic/pull/206) ([gracchus163](https://github.com/gracchus163))
+- Lowered volume of sounds [\#205](https://github.com/JFreegman/toxic/pull/205) ([loadedice](https://github.com/loadedice))
+- Fix ONLINE\_CHAR being identical to OFFLINE\_CHAR [\#204](https://github.com/JFreegman/toxic/pull/204) ([zetok](https://github.com/zetok))
+- Put man pages in right place by default \(\#202\) [\#203](https://github.com/JFreegman/toxic/pull/203) ([zetok](https://github.com/zetok))
+- Popup notifications & core adjustments [\#200](https://github.com/JFreegman/toxic/pull/200) ([ghost](https://github.com/ghost))
+- Fixed sounds not playing [\#199](https://github.com/JFreegman/toxic/pull/199) ([ghost](https://github.com/ghost))
+- README.md: add precompiled binaries [\#198](https://github.com/JFreegman/toxic/pull/198) ([Ansa89](https://github.com/Ansa89))
+
+## [v0.4.6](https://github.com/JFreegman/toxic/tree/v0.4.6) (2014-07-23)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.4.5...v0.4.6)
+
+**Implemented enhancements:**
+
+- "Officially Deprecated" build for 32-bit? [\#192](https://github.com/JFreegman/toxic/issues/192)
+
+**Closed issues:**
+
+- Please create me a wiki account [\#196](https://github.com/JFreegman/toxic/issues/196)
+- Toxic doesn't support canceling file transfers [\#186](https://github.com/JFreegman/toxic/issues/186)
+- hashes of binaries? [\#185](https://github.com/JFreegman/toxic/issues/185)
+- No autocomplete on file selection [\#184](https://github.com/JFreegman/toxic/issues/184)
+- valgrind [\#178](https://github.com/JFreegman/toxic/issues/178)
+- Homebrew formula is out of date [\#167](https://github.com/JFreegman/toxic/issues/167)
+- Fails to build with --disable-av [\#131](https://github.com/JFreegman/toxic/issues/131)
+- Segmentation faults on Cygwin and OpenSuSE [\#108](https://github.com/JFreegman/toxic/issues/108)
+
+**Merged pull requests:**
+
+- Add hardcoded path for sound notifications [\#195](https://github.com/JFreegman/toxic/pull/195) ([Ansa89](https://github.com/Ansa89))
+- Makefile: little refactoring [\#193](https://github.com/JFreegman/toxic/pull/193) ([Ansa89](https://github.com/Ansa89))
+- Fixed some build errors [\#190](https://github.com/JFreegman/toxic/pull/190) ([ghost](https://github.com/ghost))
+- Makefile fix [\#188](https://github.com/JFreegman/toxic/pull/188) ([Ansa89](https://github.com/Ansa89))
+- Added sound notifications, libconfig support, and more... [\#187](https://github.com/JFreegman/toxic/pull/187) ([ghost](https://github.com/ghost))
+
+## [v0.4.5](https://github.com/JFreegman/toxic/tree/v0.4.5) (2014-07-14)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.4.1...v0.4.5)
+
+**Closed issues:**
+
+- building on freebsd [\#177](https://github.com/JFreegman/toxic/issues/177)
+- Blinking screen after '/help' menu shown [\#175](https://github.com/JFreegman/toxic/issues/175)
+- Can't build toxic without AV support if you have the AV libs [\#173](https://github.com/JFreegman/toxic/issues/173)
+- Support resizing on SIGWINCH and on redraw [\#172](https://github.com/JFreegman/toxic/issues/172)
+- Broken backspace [\#163](https://github.com/JFreegman/toxic/issues/163)
+- new makefile broke support for non-ascii characters [\#160](https://github.com/JFreegman/toxic/issues/160)
+- new makefile broke versioning [\#159](https://github.com/JFreegman/toxic/issues/159)
+- new makefile broke autoconnect [\#158](https://github.com/JFreegman/toxic/issues/158)
+- Compilation error [\#143](https://github.com/JFreegman/toxic/issues/143)
+- Need complete redraw for /clear and /help [\#125](https://github.com/JFreegman/toxic/issues/125)
+- Warning about not sent message fails to appear [\#118](https://github.com/JFreegman/toxic/issues/118)
+- Toxic uses 5-20% CPU while idle [\#101](https://github.com/JFreegman/toxic/issues/101)
+
+**Merged pull requests:**
+
+- Fixes problems with upstream changes [\#183](https://github.com/JFreegman/toxic/pull/183) ([ghost](https://github.com/ghost))
+- Use long int instead uint64\_t [\#181](https://github.com/JFreegman/toxic/pull/181) ([Ansa89](https://github.com/Ansa89))
+- Forgot about help [\#180](https://github.com/JFreegman/toxic/pull/180) ([Ansa89](https://github.com/Ansa89))
+- Add option to disable audio support [\#179](https://github.com/JFreegman/toxic/pull/179) ([Ansa89](https://github.com/Ansa89))
+- Make closing window end call [\#174](https://github.com/JFreegman/toxic/pull/174) ([ghost](https://github.com/ghost))
+- Manpage fix [\#170](https://github.com/JFreegman/toxic/pull/170) ([Ansa89](https://github.com/Ansa89))
+- Add help target and toxic.conf manpage [\#169](https://github.com/JFreegman/toxic/pull/169) ([Ansa89](https://github.com/Ansa89))
+- Fixed setting buffer to half of the size [\#165](https://github.com/JFreegman/toxic/pull/165) ([ghost](https://github.com/ghost))
+- Add manpage [\#164](https://github.com/JFreegman/toxic/pull/164) ([Ansa89](https://github.com/Ansa89))
+- Try to fix autoconnect [\#161](https://github.com/JFreegman/toxic/pull/161) ([Ansa89](https://github.com/Ansa89))
+- Wide characters support [\#157](https://github.com/JFreegman/toxic/pull/157) ([Ansa89](https://github.com/Ansa89))
+- Polishing README.md [\#155](https://github.com/JFreegman/toxic/pull/155) ([theGeekPirate](https://github.com/theGeekPirate))
+- README.md: add build status [\#153](https://github.com/JFreegman/toxic/pull/153) ([Ansa89](https://github.com/Ansa89))
+- Update readme instructions [\#152](https://github.com/JFreegman/toxic/pull/152) ([Ansa89](https://github.com/Ansa89))
+- Forgot to set index in some callbacks [\#151](https://github.com/JFreegman/toxic/pull/151) ([ghost](https://github.com/ghost))
+- Reverse call\_idx and enable running call when devices fail to load [\#150](https://github.com/JFreegman/toxic/pull/150) ([ghost](https://github.com/ghost))
+- Remove autotools dependency [\#149](https://github.com/JFreegman/toxic/pull/149) ([Ansa89](https://github.com/Ansa89))
+- Cast localtime [\#147](https://github.com/JFreegman/toxic/pull/147) ([Ansa89](https://github.com/Ansa89))
+- Changed code a bit and added new features [\#146](https://github.com/JFreegman/toxic/pull/146) ([ghost](https://github.com/ghost))
+
+## [0.4.1](https://github.com/JFreegman/toxic/tree/0.4.1) (2014-06-19)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.4.0...0.4.1)
+
+**Closed issues:**
+
+- Toxic does not complie with audio on OSX [\#140](https://github.com/JFreegman/toxic/issues/140)
+- compiling error [\#139](https://github.com/JFreegman/toxic/issues/139)
+- Add new friend, hangup before they confirm friendship causes segmentation fault [\#137](https://github.com/JFreegman/toxic/issues/137)
+- build fail [\#124](https://github.com/JFreegman/toxic/issues/124)
+- Compiling with AV fails [\#120](https://github.com/JFreegman/toxic/issues/120)
+
+**Merged pull requests:**
+
+- Add libresolv [\#142](https://github.com/JFreegman/toxic/pull/142) ([jin-eld](https://github.com/jin-eld))
+- Search for OpenAL framework on OSX [\#141](https://github.com/JFreegman/toxic/pull/141) ([jin-eld](https://github.com/jin-eld))
+
+## [0.4.0](https://github.com/JFreegman/toxic/tree/0.4.0) (2014-06-01)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.3.0.1...0.4.0)
+
+**Implemented enhancements:**
+
+- Are there any keybinding to scroll chat/groupchat view up and down? [\#74](https://github.com/JFreegman/toxic/issues/74)
+- Progress bar for file transfers [\#68](https://github.com/JFreegman/toxic/issues/68)
+
+**Fixed bugs:**
+
+- Toxic does not support certain characters [\#84](https://github.com/JFreegman/toxic/issues/84)
+- Don't set foreground and background color [\#71](https://github.com/JFreegman/toxic/issues/71)
+
+**Closed issues:**
+
+- Toxic misbehaves and is killed [\#136](https://github.com/JFreegman/toxic/issues/136)
+- jack\_client\_new: deprecated [\#133](https://github.com/JFreegman/toxic/issues/133)
+- build error on os x 10.9 [\#129](https://github.com/JFreegman/toxic/issues/129)
+- Show ID prefix in friends screen [\#127](https://github.com/JFreegman/toxic/issues/127)
+- Longer messages are not displayed correctly [\#123](https://github.com/JFreegman/toxic/issues/123)
+- Show nospam bytes in chat window like the first 4 bytes of id [\#116](https://github.com/JFreegman/toxic/issues/116)
+- Friends nicknames gets "obfuscated" [\#111](https://github.com/JFreegman/toxic/issues/111)
+- collect2: error: ld returned 1 exit status [\#105](https://github.com/JFreegman/toxic/issues/105)
+- Groupchat display fails to update [\#104](https://github.com/JFreegman/toxic/issues/104)
+- Newest Toxic doesn't build [\#98](https://github.com/JFreegman/toxic/issues/98)
+
+**Merged pull requests:**
+
+- Update README.md [\#134](https://github.com/JFreegman/toxic/pull/134) ([zetok](https://github.com/zetok))
+- Update audio\_call.c [\#132](https://github.com/JFreegman/toxic/pull/132) ([Impyy](https://github.com/Impyy))
+- Not done yet. [\#130](https://github.com/JFreegman/toxic/pull/130) ([ghost](https://github.com/ghost))
+- Fix file sender null terminator. [\#128](https://github.com/JFreegman/toxic/pull/128) ([aitjcize](https://github.com/aitjcize))
+- Drop typedef redeclarations [\#122](https://github.com/JFreegman/toxic/pull/122) ([czarkoff](https://github.com/czarkoff))
+- Include "pthread.h" [\#121](https://github.com/JFreegman/toxic/pull/121) ([czarkoff](https://github.com/czarkoff))
+- Wow [\#119](https://github.com/JFreegman/toxic/pull/119) ([ghost](https://github.com/ghost))
+- Use default terminal fg/bg colors when we can. [\#117](https://github.com/JFreegman/toxic/pull/117) ([ooesili](https://github.com/ooesili))
+- Fixed support for wide characters [\#113](https://github.com/JFreegman/toxic/pull/113) ([graboy](https://github.com/graboy))
+- Mention av [\#110](https://github.com/JFreegman/toxic/pull/110) ([stqism](https://github.com/stqism))
+- allow history scrolling [\#109](https://github.com/JFreegman/toxic/pull/109) ([JFreegman](https://github.com/JFreegman))
+- Only those who appreciate small things [\#107](https://github.com/JFreegman/toxic/pull/107) ([ghost](https://github.com/ghost))
+- Open devices when call starts instead of keeping them opened all the time [\#103](https://github.com/JFreegman/toxic/pull/103) ([ghost](https://github.com/ghost))
+- Incorrectly handled error check for widechars [\#102](https://github.com/JFreegman/toxic/pull/102) ([graboy](https://github.com/graboy))
+- Fix toxic build when toxav is not available [\#100](https://github.com/JFreegman/toxic/pull/100) ([jin-eld](https://github.com/jin-eld))
+- Add checks for pthreads to the build system [\#99](https://github.com/JFreegman/toxic/pull/99) ([jin-eld](https://github.com/jin-eld))
+- Fixes and stuff... [\#97](https://github.com/JFreegman/toxic/pull/97) ([ghost](https://github.com/ghost))
+
+## [0.3.0.1](https://github.com/JFreegman/toxic/tree/0.3.0.1) (2014-03-12)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.3.0...0.3.0.1)
+
+**Merged pull requests:**
+
+- SPELLING IS FOR FOOLS [\#94](https://github.com/JFreegman/toxic/pull/94) ([lehitoskin](https://github.com/lehitoskin))
+
+## [0.3.0](https://github.com/JFreegman/toxic/tree/0.3.0) (2014-03-12)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.7...0.3.0)
+
+**Fixed bugs:**
+
+- SIGSEVG upon friend hanging up [\#89](https://github.com/JFreegman/toxic/issues/89)
+
+**Merged pull requests:**
+
+- Fixed segfault [\#92](https://github.com/JFreegman/toxic/pull/92) ([ghost](https://github.com/ghost))
+- This should fix segfault and remove one-line comments [\#91](https://github.com/JFreegman/toxic/pull/91) ([ghost](https://github.com/ghost))
+- Fixed another clang issue with bools that broek file sending. [\#90](https://github.com/JFreegman/toxic/pull/90) ([Jman012](https://github.com/Jman012))
+- Toxic audio support [\#88](https://github.com/JFreegman/toxic/pull/88) ([ghost](https://github.com/ghost))
+- Fixed clang error, disabling the execute module. [\#87](https://github.com/JFreegman/toxic/pull/87) ([Jman012](https://github.com/Jman012))
+- Issue \#84 fixed [\#86](https://github.com/JFreegman/toxic/pull/86) ([thevar1able](https://github.com/thevar1able))
+- Fixing fall-back from IPv6 to IPv4 [\#85](https://github.com/JFreegman/toxic/pull/85) ([micrictor](https://github.com/micrictor))
+
+## [0.2.7](https://github.com/JFreegman/toxic/tree/0.2.7) (2014-03-01)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.6.1...0.2.7)
+
+**Closed issues:**
+
+- Toxic segfault when window is closed [\#81](https://github.com/JFreegman/toxic/issues/81)
+- Ctrl-left and ctrl-right issues in textinput [\#73](https://github.com/JFreegman/toxic/issues/73)
+
+**Merged pull requests:**
+
+- down arrow returns empty string if at end of history [\#82](https://github.com/JFreegman/toxic/pull/82) ([kl4ng](https://github.com/kl4ng))
+- Fallback to loading /usr/share/toxic/DHTservers. [\#80](https://github.com/JFreegman/toxic/pull/80) ([viric](https://github.com/viric))
+
+## [0.2.6.1](https://github.com/JFreegman/toxic/tree/0.2.6.1) (2014-02-23)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.6...0.2.6.1)
+
+## [0.2.6](https://github.com/JFreegman/toxic/tree/0.2.6) (2014-02-23)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.5...0.2.6)
+
+## [0.2.5](https://github.com/JFreegman/toxic/tree/0.2.5) (2014-02-22)
+[Full Changelog](https://github.com/JFreegman/toxic/compare/prealpha_win32_r8...0.2.5)
+
+**Fixed bugs:**
+
+- Back space leaves ć character [\#44](https://github.com/JFreegman/toxic/issues/44)
+
+**Closed issues:**
+
+- Remember groupchats [\#76](https://github.com/JFreegman/toxic/issues/76)
+- Segfault [\#75](https://github.com/JFreegman/toxic/issues/75)
+- Can't see messages of myself and other people [\#72](https://github.com/JFreegman/toxic/issues/72)
+- binary blob in source [\#66](https://github.com/JFreegman/toxic/issues/66)
+- symbol lookup error [\#54](https://github.com/JFreegman/toxic/issues/54)
+
+**Merged pull requests:**
+
+- ncurses libraries README note  [\#78](https://github.com/JFreegman/toxic/pull/78) ([kl4ng](https://github.com/kl4ng))
+- umask such that stored files are u+rw only [\#77](https://github.com/JFreegman/toxic/pull/77) ([alevy](https://github.com/alevy))
+- Fix groupchat cursor movement. [\#63](https://github.com/JFreegman/toxic/pull/63) ([aitjcize](https://github.com/aitjcize))
+- Fix wchar cursor movement. [\#62](https://github.com/JFreegman/toxic/pull/62) ([aitjcize](https://github.com/aitjcize))
+- api update [\#61](https://github.com/JFreegman/toxic/pull/61) ([naxuroqa](https://github.com/naxuroqa))
+- Add option to switch off ipv6. [\#60](https://github.com/JFreegman/toxic/pull/60) ([aitjcize](https://github.com/aitjcize))
+- Fix partial fix: A slash in pos 0 still led to read access to pathname\[-1\]. [\#59](https://github.com/JFreegman/toxic/pull/59) ([FullName](https://github.com/FullName))
+- Fix corresponding API name changes in toxcore. [\#58](https://github.com/JFreegman/toxic/pull/58) ([aitjcize](https://github.com/aitjcize))
+- Fix API ret code changes of ToxCore [\#57](https://github.com/JFreegman/toxic/pull/57) ([aitjcize](https://github.com/aitjcize))
+
+## [prealpha_win32_r8](https://github.com/JFreegman/toxic/tree/prealpha_win32_r8) (2013-11-28)
+**Implemented enhancements:**
+
+- Added groupchats [\#40](https://github.com/JFreegman/toxic/pull/40) ([JFreegman](https://github.com/JFreegman))
+- Adapted to ipv6-enabled tox [\#38](https://github.com/JFreegman/toxic/pull/38) ([FullName](https://github.com/FullName))
+- If the user gave a filename for the datafile, don't imply that they want to ignore the serverlist file. [\#37](https://github.com/JFreegman/toxic/pull/37) ([FullName](https://github.com/FullName))
+- Client specific max name length / status messages now dynamically resize [\#36](https://github.com/JFreegman/toxic/pull/36) ([JFreegman](https://github.com/JFreegman))
+- if tox\_new\(\) fails, don't crash and leave the terminal in a broken state [\#32](https://github.com/JFreegman/toxic/pull/32) ([FullName](https://github.com/FullName))
+- truncate friends' notes if they're too long [\#30](https://github.com/JFreegman/toxic/pull/30) ([JFreegman](https://github.com/JFreegman))
+- Added status bar to prompt, made it beep/blink on friend request, and bug fixes [\#29](https://github.com/JFreegman/toxic/pull/29) ([JFreegman](https://github.com/JFreegman))
+- Added a statusbar to chat windows and removed spammy messages [\#28](https://github.com/JFreegman/toxic/pull/28) ([JFreegman](https://github.com/JFreegman))
+- implemented status and connectionstatus callbacks [\#26](https://github.com/JFreegman/toxic/pull/26) ([JFreegman](https://github.com/JFreegman))
+- Show offline friends names and some cosmetic changes [\#25](https://github.com/JFreegman/toxic/pull/25) ([JFreegman](https://github.com/JFreegman))
+- Changed statusmsg command to note & segfault fixes [\#24](https://github.com/JFreegman/toxic/pull/24) ([JFreegman](https://github.com/JFreegman))
+- refactor command argument parsing [\#23](https://github.com/JFreegman/toxic/pull/23) ([lukechampine](https://github.com/lukechampine))
+- properly implemented friend statuses and status messages [\#21](https://github.com/JFreegman/toxic/pull/21) ([JFreegman](https://github.com/JFreegman))
+- implemented friend deletion [\#15](https://github.com/JFreegman/toxic/pull/15) ([JFreegman](https://github.com/JFreegman))
+- Fix configure for Free BSD [\#11](https://github.com/JFreegman/toxic/pull/11) ([jin-eld](https://github.com/jin-eld))
+- Add check for setlocale\(\) [\#10](https://github.com/JFreegman/toxic/pull/10) ([manuel-arguelles](https://github.com/manuel-arguelles))
+- Update build system [\#7](https://github.com/JFreegman/toxic/pull/7) ([jin-eld](https://github.com/jin-eld))
+- Added travis integration [\#6](https://github.com/JFreegman/toxic/pull/6) ([stqism](https://github.com/stqism))
+- Use new public api [\#5](https://github.com/JFreegman/toxic/pull/5) ([fhahn](https://github.com/fhahn))
+- Add widechar checks [\#2](https://github.com/JFreegman/toxic/pull/2) ([jin-eld](https://github.com/jin-eld))
+
+**Fixed bugs:**
+
+- Let windows.c actually get the tox \*m. [\#41](https://github.com/JFreegman/toxic/pull/41) ([Jman012](https://github.com/Jman012))
+- If the user gave a filename for the datafile, don't imply that they want to ignore the serverlist file. [\#37](https://github.com/JFreegman/toxic/pull/37) ([FullName](https://github.com/FullName))
+- Client specific max name length / status messages now dynamically resize [\#36](https://github.com/JFreegman/toxic/pull/36) ([JFreegman](https://github.com/JFreegman))
+- Merged pr6 [\#34](https://github.com/JFreegman/toxic/pull/34) ([stqism](https://github.com/stqism))
+- made error handling more consistent and added exit function [\#33](https://github.com/JFreegman/toxic/pull/33) ([JFreegman](https://github.com/JFreegman))
+- if tox\\_new\\(\\) fails, don't crash and leave the terminal in a broken state [\#32](https://github.com/JFreegman/toxic/pull/32) ([FullName](https://github.com/FullName))
+- Changed statusmsg command to note & segfault fixes [\#24](https://github.com/JFreegman/toxic/pull/24) ([JFreegman](https://github.com/JFreegman))
+- fix buffer overflows and format issues [\#20](https://github.com/JFreegman/toxic/pull/20) ([JFreegman](https://github.com/JFreegman))
+- Fix blocking while waiting for key [\#17](https://github.com/JFreegman/toxic/pull/17) ([manuel-arguelles](https://github.com/manuel-arguelles))
+- fixed "free\(\): invalid pointer" when XDG\_CONFIG\_HOME is set [\#16](https://github.com/JFreegman/toxic/pull/16) ([gs93](https://github.com/gs93))
+- Make sure toxic compiles on MinGW/Win32 again [\#14](https://github.com/JFreegman/toxic/pull/14) ([jin-eld](https://github.com/jin-eld))
+- Fix for the "bad character" when doing backspace in chat window [\#12](https://github.com/JFreegman/toxic/pull/12) ([jin-eld](https://github.com/jin-eld))
+- Fix configure for Free BSD [\#11](https://github.com/JFreegman/toxic/pull/11) ([jin-eld](https://github.com/jin-eld))
+- Fix configure script for ncurses without ncursesw [\#9](https://github.com/JFreegman/toxic/pull/9) ([manuel-arguelles](https://github.com/manuel-arguelles))
+- Fix configure script for mingw32 [\#8](https://github.com/JFreegman/toxic/pull/8) ([jin-eld](https://github.com/jin-eld))
+- warning: comparison of integers of different signs: 'int' and 'unsigned long' [\#3](https://github.com/JFreegman/toxic/pull/3) ([1100110](https://github.com/1100110))
+
+**Merged pull requests:**
+
+- Make sure friend message is null-terminated else generate garbate on screen [\#56](https://github.com/JFreegman/toxic/pull/56) ([aitjcize](https://github.com/aitjcize))
+- Fix trailing slashes which leads to segfault. [\#55](https://github.com/JFreegman/toxic/pull/55) ([aitjcize](https://github.com/aitjcize))
+- fix cflags [\#53](https://github.com/JFreegman/toxic/pull/53) ([JFreegman](https://github.com/JFreegman))
+- Fix 93ab16c [\#52](https://github.com/JFreegman/toxic/pull/52) ([urras](https://github.com/urras))
+- Offer solution for "error while loading shared libraries: libtoxcore.so.... [\#51](https://github.com/JFreegman/toxic/pull/51) ([urras](https://github.com/urras))
+- Implemented file transfers [\#50](https://github.com/JFreegman/toxic/pull/50) ([JFreegman](https://github.com/JFreegman))
+- Fix check for toxcore by linking sodium in the correct place [\#47](https://github.com/JFreegman/toxic/pull/47) ([devurandom](https://github.com/devurandom))
+- Changed order of servers [\#46](https://github.com/JFreegman/toxic/pull/46) ([grimd34th](https://github.com/grimd34th))
+- set friendnames properly and some fixes [\#45](https://github.com/JFreegman/toxic/pull/45) ([JFreegman](https://github.com/JFreegman))
+- moved misc helper functions to separate file and removed redundant includes [\#43](https://github.com/JFreegman/toxic/pull/43) ([JFreegman](https://github.com/JFreegman))
+- Refactored prompt command parser to work with all window types and moved command stuff to separate files [\#42](https://github.com/JFreegman/toxic/pull/42) ([JFreegman](https://github.com/JFreegman))
+- Ipv6.init connection [\#39](https://github.com/JFreegman/toxic/pull/39) ([FullName](https://github.com/FullName))
+- Remove DHT window [\#13](https://github.com/JFreegman/toxic/pull/13) ([JFreegman](https://github.com/JFreegman))
+- Update README.md [\#4](https://github.com/JFreegman/toxic/pull/4) ([notadecent](https://github.com/notadecent))
+- Toxic standalone [\#1](https://github.com/JFreegman/toxic/pull/1) ([jin-eld](https://github.com/jin-eld))
+
+
+
+\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

INSTALL.md

@@ -1,55 +1,53 @@
 # Installation
-* [Dependencies](#deps)
-  * [OS X Notes](#deps_osx)
+* [Dependencies](#dependencies)
+  * [OS X Notes](#os-x-notes)
 * [Compiling](#compiling)
-  * [Documentation](#docs)
+  * [Documentation](#documentation)
 * [Notes](#notes)
-  * [Compilation variables](#comp_vars)
+  * [Compilation variables](#compilation-variables)
   * [Packaging](#packaging)
 
-<a name="deps" />
 ## Dependencies
-| Name                                                 | Needed by                  | Debian package   |
-|------------------------------------------------------|----------------------------|------------------|
-| [Tox Core](https://github.com/irungentoo/toxcore)    | BASE                       | *None*           |
-| [NCurses](https://www.gnu.org/software/ncurses)      | BASE                       | libncursesw5-dev |
-| [LibConfig](http://www.hyperrealm.com/libconfig)     | BASE                       | libconfig-dev    |
-| [GNUmake](https://www.gnu.org/software/make)         | BASE                       | make             |
-| [Tox Core AV](https://github.com/irungentoo/toxcore) | AUDIO                      | *None*           |
-| [OpenAL](http://openal.org)                          | AUDIO, SOUND NOTIFICATIONS | libopenal-dev    |
-| [OpenALUT](http://openal.org)                        | SOUND NOTIFICATIONS        | libalut-dev      |
-| [LibNotify](https://developer.gnome.org/libnotify)   | DESKTOP NOTIFICATIONS      | libnotify-dev    |
-| [AsciiDoc](http://asciidoc.org/index.html)           | DOCUMENTATION<sup>1</sup>  | asciidoc         |
-<sup>1</sup>: see [Documentation](#docs)
+| Name                                                 | Needed by                  | Debian package      |
+|------------------------------------------------------|----------------------------|---------------------|
+| [Tox Core](https://github.com/toktok/c-toxcore)      | BASE                       | *None*              |
+| [NCurses](https://www.gnu.org/software/ncurses)      | BASE                       | libncursesw5-dev    |
+| [LibConfig](http://www.hyperrealm.com/libconfig)     | BASE                       | libconfig-dev       |
+| [GNUmake](https://www.gnu.org/software/make)         | BASE                       | make                |
+| [libcurl](http://curl.haxx.se/)                      | BASE                       | libcurl4-openssl-dev|
+| [libqrencode](https://fukuchi.org/works/qrencode/)   | BASE                       | libqrencode-dev     |
+| [Tox Core AV](https://github.com/toktok/c-toxcore)   | AUDIO                      | *None*              |
+| [OpenAL](http://openal.org)                          | AUDIO, SOUND NOTIFICATIONS | libopenal-dev       |
+| [OpenALUT](http://openal.org)                        | SOUND NOTIFICATIONS        | libalut-dev         |
+| [LibNotify](https://developer.gnome.org/libnotify)   | DESKTOP NOTIFICATIONS      | libnotify-dev       |
+| [Python 3](http://www.python.org/)                   | PYTHON                     | python3-dev         |
+| [AsciiDoc](http://asciidoc.org/index.html)           | DOCUMENTATION<sup>1</sup>  | asciidoc            |
+
+<sup>1</sup>: see [Documentation](#documentation)
 
-<a name="deps_osx" />
 #### OS X Notes
 Using [Homebrew](http://brew.sh):
 ```
 brew install openal-soft freealut libconfig
-brew install https://raw.githubusercontent.com/Tox/homebrew-tox/master/Formula/libtoxcore.rb
-brew install https://raw.githubusercontent.com/Homebrew/homebrew-x11/master/libnotify.rb
+brew install --HEAD https://raw.githubusercontent.com/Tox/homebrew-tox/master/Formula/libtoxcore.rb
+brew install libnotify
 ```
 
-You can omit `libnotify` if you intend to build without desktop notifications enabled. 
+You can omit `libnotify` if you intend to build without desktop notifications enabled.
 
-<a name="Compiling">
 ## Compiling
 ```
 make PREFIX="/where/to/install"
 sudo make install PREFIX="/where/to/install"
 ```
 
-<a name="docs" />
 #### Documentation
 Run `make doc` in the build directory after editing the asciidoc files to regenerate the manpages.<br />
 **NOTE FOR DEVELOPERS**: asciidoc files and generated manpages will need to be commited together.<br />
 **NOTE FOR EVERYONE**: [asciidoc](http://asciidoc.org/index.html) (and this step) is only required for regenerating manpages when you modify them.
 
-<a name="notes" />
 ## Notes
 
-<a name="comp_vars" />
 #### Compilation variables
 * You can add specific flags to the Makefile with `USER_CFLAGS=""` and/or `USER_LDFLAGS=""`
 * You can pass your own flags to the Makefile with `CFLAGS=""` and/or `LDFLAGS=""` (this will supersede the default ones)
@@ -58,11 +56,11 @@ Run `make doc` in the build directory after editing the asciidoc files to regene
   * `DISABLE_AV=1` → build toxic without audio call support
   * `DISABLE_SOUND_NOTIFY=1` → build toxic without sound notifications support
   * `DISABLE_DESKTOP_NOTIFY=1` → build toxic without desktop notifications support
+* Features excluded from the default build must be explicitly enabled using special variables:
+  * `ENABLE_PYTHON=1` → build toxic with Python scripting support
 
-<a name="packaging" />
 #### Packaging
 * For packaging purpose, you can use `DESTDIR=""` to specify a directory where to store installed files
 * `DESTDIR=""` can be used in addition to `PREFIX=""`:
   * `DESTDIR=""` is meant to specify a directory where to store installed files (ex: "/tmp/build/pkg")
   * `PREFIX=""` is meant to specify a prefix directory for binaries and data files (ex: "/usr/local")
-

Makefile

@@ -3,18 +3,18 @@ CFG_DIR = $(BASE_DIR)/cfg
 
 -include $(CFG_DIR)/global_vars.mk
 
-LIBS = libtoxcore ncursesw libconfig
+LIBS = libtoxcore ncursesw libconfig libqrencode
 
-CFLAGS = -std=gnu99 -pthread -Wall -g
+CFLAGS = -std=gnu99 -pthread -Wall -g -fstack-protector-all
 CFLAGS += '-DTOXICVER="$(VERSION)"' -DHAVE_WIDECHAR -D_XOPEN_SOURCE_EXTENDED -D_FILE_OFFSET_BITS=64
 CFLAGS += '-DPACKAGE_DATADIR="$(abspath $(DATADIR))"'
 CFLAGS += $(USER_CFLAGS)
 LDFLAGS = $(USER_LDFLAGS)
 
-OBJ = chat.o chat_commands.o configdir.o dns.o execute.o file_transfers.o notify.o
-OBJ += friendlist.o global_commands.o groupchat.o line_info.o input.o help.o autocomplete.o
-OBJ += log.o misc_tools.o prompt.o settings.o toxic.o toxic_strings.o windows.o message_queue.o
-OBJ += group_commands.o term_mplex.o
+OBJ = autocomplete.o avatars.o bootstrap.o chat.o chat_commands.o configdir.o curl_util.o execute.o
+OBJ += file_transfers.o friendlist.o global_commands.o group_commands.o groupchat.o help.o input.o
+OBJ += line_info.o log.o message_queue.o misc_tools.o name_lookup.o notify.o prompt.o qr_code.o settings.o
+OBJ += term_mplex.o toxic.o toxic_strings.o windows.o
 
 # Check on wich system we are running
 UNAME_S = $(shell uname -s)
@@ -24,9 +24,15 @@ endif
 ifeq ($(UNAME_S), FreeBSD)
     -include $(CFG_DIR)/systems/FreeBSD.mk
 endif
+ifeq ($(UNAME_S), DragonFly)
+    -include $(CFG_DIR)/systems/FreeBSD.mk
+endif
 ifeq ($(UNAME_S), OpenBSD)
     -include $(CFG_DIR)/systems/FreeBSD.mk
 endif
+ifeq ($(UNAME_S), NetBSD)
+    -include $(CFG_DIR)/systems/FreeBSD.mk
+endif
 ifeq ($(UNAME_S), Darwin)
     -include $(CFG_DIR)/systems/Darwin.mk
 endif
@@ -59,6 +65,10 @@ $(BUILD_DIR)/toxic: $(OBJ)
 	@echo "  LD    $(@:$(BUILD_DIR)/%=%)"
 	@$(CC) $(CFLAGS) -o $(BUILD_DIR)/toxic $(OBJ) $(LDFLAGS)
 
+$(BUILD_DIR)/osx_video.o: $(SRC_DIR)/$(OSX_VIDEO)
+	@echo "  CC    $(@:$(BUILD_DIR)/)osx_video.o"
+	@$(CC) $(CFLAGS) -o $(BUILD_DIR)/osx_video.o -c $(SRC_DIR)/$(OSX_VIDEO)
+
 $(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
 	@if [ ! -e $(BUILD_DIR) ]; then \
 		mkdir -p $(BUILD_DIR) ;\

README.md

@@ -1,26 +1,16 @@
-# Toxic [![Build Status](https://travis-ci.org/Tox/toxic.png?branch=master)](https://travis-ci.org/Tox/toxic)
-Toxic is a [Tox](https://tox.im)-based instant messenging client which formerly resided in the [Tox core repository](https://github.com/irungentoo/toxcore), and is now available as a standalone application.
+<a href="https://scan.coverity.com/projects/toxic-tox">
+  <img alt="Coverity Scan Build Status"
+       src="https://scan.coverity.com/projects/4975/badge.svg"/>
+</a>
+
+Toxic is a [Tox](https://tox.chat)-based instant messenging client which formerly resided in the [Tox core repository](https://github.com/toktok/c-toxcore), and is now available as a standalone application.
 
 [![Toxic Screenshot](https://i.imgur.com/san99Z2.png "Home Screen")](https://i.imgur.com/san99Z2.png)
 
 ## Installation
-[Use our repositories](https://wiki.tox.im/Binaries#Linux)<br />
+[Use our repositories](https://wiki.tox.chat/binaries#other_linux)<br />
 [Compile it yourself](/INSTALL.md)
 
-## Downloads
-If you don't like installation methods listed above, you can still download precompiled binaries from [jenkins](https://jenkins.libtoxcore.so):
-* [Linux 32 bit](https://jenkins.libtoxcore.so/job/toxic_linux_i386/lastSuccessfulBuild/artifact/toxic_linux_i386.tar.xz) [![Build Status](https://jenkins.libtoxcore.so/job/toxic_linux_i386/badge/icon)](https://jenkins.libtoxcore.so/job/toxic_linux_i386/lastSuccessfulBuild/artifact/toxic_linux_i386.tar.xz)
-* [Linux 64 bit](https://jenkins.libtoxcore.so/job/toxic_linux_amd64/lastSuccessfulBuild/artifact/toxic_linux_amd64.tar.xz) [![Build Status](https://jenkins.libtoxcore.so/job/toxic_linux_amd64/badge/icon)](https://jenkins.libtoxcore.so/job/toxic_linux_amd64/lastSuccessfulBuild/artifact/toxic_linux_amd64.tar.xz)
-* [~~Linux ARMv6~~](https://jenkins.libtoxcore.so/job/toxic_linux_armv6/lastSuccessfulBuild/artifact/toxic_linux_armv6.tar.xz) **CURRENTLY DISABLED** [![Build Status](https://jenkins.libtoxcore.so/job/toxic_linux_armv6/badge/icon)](https://jenkins.libtoxcore.so/job/toxic_linux_armv6/lastSuccessfulBuild/artifact/toxic_linux_armv6.tar.xz)
-
-#### DEBs packages
-* [toxic-i386.deb](https://jenkins.libtoxcore.so/job/toxic-linux-pkg/lastSuccessfulBuild/artifact/toxic-i386.deb)
-* [toxic-x86_64.deb](https://jenkins.libtoxcore.so/job/toxic-linux-pkg/lastSuccessfulBuild/artifact/toxic-x86_64.deb)
-
-#### RPMs packages
-* [toxic-i386.rpm](https://jenkins.libtoxcore.so/job/toxic-linux-pkg/lastSuccessfulBuild/artifact/toxic-i386.rpm)
-* [toxic-x86_64.rpm](https://jenkins.libtoxcore.so/job/toxic-linux-pkg/lastSuccessfulBuild/artifact/toxic-x86_64.rpm)
-
 ## Settings
 Running Toxic for the first time creates an empty file called toxic.conf in your home configuration directory ("~/.config/tox" for Linux users). Adding options to this file allows you to enable auto-logging, change the time format (12/24 hour), and much more.
 You can view our example config file [here](misc/toxic.conf.example).

apidoc/python/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = toxic_api
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

apidoc/python/source/conf.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# toxic_api documentation build configuration file, created by
+# sphinx-quickstart on Tue May 16 08:58:24 2017.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = []
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = 'toxic_api'
+copyright = '2017, Jakob Kreuze'
+author = 'Jakob Kreuze'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '0.8.1'
+# The full version, including alpha/beta/rc tags.
+release = '0.8.1'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+# html_theme_options = {}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+
+# -- Options for HTMLHelp output ------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'toxic_apidoc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #
+    # 'papersize': 'letterpaper',
+
+    # The font size ('10pt', '11pt' or '12pt').
+    #
+    # 'pointsize': '10pt',
+
+    # Additional stuff for the LaTeX preamble.
+    #
+    # 'preamble': '',
+
+    # Latex figure (float) alignment
+    #
+    # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'toxic_api.tex', 'toxic\\_api Documentation',
+     'Jakob Kreuze', 'manual'),
+]
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'toxic_api', 'toxic_api Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'toxic_api', 'toxic_api Documentation',
+     author, 'toxic_api', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+
+

apidoc/python/source/examples.rst

@@ -0,0 +1,8 @@
+============
+API Examples
+============
+
+Fortune
+=======
+.. literalinclude:: fortune.py
+   :language: python

apidoc/python/source/fortune.py

@@ -0,0 +1,37 @@
+import toxic_api
+import random
+
+FORTUNES = [
+    "A bug in the code is worth two in the documentation.",
+    "A bug in the hand is better than one as yet undetected.",
+    "\"A debugged program is one for which you have not yet found the "
+    "conditions that make it fail.\" -- Jerry Ogdin"
+]
+
+def send_fortune(args):
+    """Callback function that sends the contact of the current window a
+    given number of random fortunes.
+    """
+    if len(args) != 1:
+        toxic_api.display("Only one argument allowed!")
+        return
+
+    try:
+        count = int(args[0])
+    except ValueError:
+        toxic_api.display("Argument must be a number!")
+        return
+
+    if count < 0 or count > 20:
+        toxic_api.display("Argument is too large!")
+        return
+
+    name = toxic_api.get_nick()
+
+    toxic_api.send("%s has decided to send you %d fortunes:" % (name, count))
+    for _ in range(count):
+        toxic_api.send(random.choice(FORTUNES))
+
+
+toxic_api.register("/fortune", "Send a fortune to the contact of the current "
+                   "window", send_fortune)

apidoc/python/source/index.rst

@@ -0,0 +1,9 @@
+Toxic Scripting Interface Documentation
+=======================================
+
+.. toctree::
+   :maxdepth: 2
+
+   intro
+   reference
+   examples

apidoc/python/source/intro.rst

@@ -0,0 +1,12 @@
+=========================
+Toxic Scripting Interface
+=========================
+
+A Python scripting interface to `Toxic <https://github.com/JFreegman/toxic>`_.
+
+
+Getting Started
+===============
+Toxic is compiled with Python support by default. To access the scripting interface, simply import "toxic_api" in your script.
+
+Scripts can be run by issuing "/run <path>" from toxic, or placing them in the "autorun_path" from your toxic configuration file.

apidoc/python/source/reference.rst

@@ -0,0 +1,73 @@
+=============
+API Reference
+=============
+
+Messages
+========
+.. function:: display(msg)
+
+   Display a message to the user through the current window.
+
+   :param msg: The message to display.
+   :type msg: string
+   :rtype: none
+
+.. function:: send(msg)
+
+   Send a message to the user specified by the currently open conversation.
+
+   :param msg: The message to display.
+   :type msg: string
+   :rtype: none
+
+
+State
+=====
+.. function:: get_nick()
+
+   Return the user's current nickname.
+
+   :rtype: string
+
+.. function:: get_status()
+
+   Return a string representing the user's current status. Can be either "online", "away", or "busy".
+
+   :rtype: string
+
+.. function:: get_status_message()
+
+   Return the user's current status message.
+
+   :rtype: string
+
+.. function:: get_all_friends()
+
+   Return a list of all the user's friends.
+
+   :rtype: list of (string, string) tuples containing the nickname followed by their public key
+
+
+Commands
+========
+.. function:: execute(command, class)
+
+   Executes the given command. The API exports three constants for the class parameter; GLOBAL_COMMAND, CHAT_COMMAND, and GROUPCHAT_COMMAND.
+
+   :param command: The command to execute.
+   :type command: string
+   :param class: The class of the command.
+   :type class: int
+   :rtype: none
+
+.. function:: register(command, help, callback)
+
+   Register a callback to be executed whenever command is run. The callback function will be called with one argument, a list of arguments from when the user calls the command.
+
+   :param command: The command to listen for.
+   :type command: string
+   :param help: A description of the command to be shown in the help menu.
+   :type help: string
+   :param callback: The function to be called.
+   :type callback: callable
+   :rtype: none

astylerc

@@ -0,0 +1,11 @@
+--style=kr
+        --pad-header
+        --max-code-length=120
+                          --convert-tabs
+                          --indent-switches
+                          --pad-oper
+                          --align-pointer=name
+                                  --align-reference=name
+                                          --preserve-date
+                                          --lineend=linux
+                                                  --break-blocks

cfg/checks/audio.mk

@@ -1,20 +1,20 @@
 # Variables for audio call support
 AUDIO_LIBS = libtoxav openal
 AUDIO_CFLAGS = -DAUDIO
-ifneq (, $(findstring device.o, $(OBJ)))
+ifneq (, $(findstring audio_device.o, $(OBJ)))
     AUDIO_OBJ = audio_call.o
 else
-    AUDIO_OBJ = audio_call.o device.o
+    AUDIO_OBJ = audio_call.o audio_device.o
 endif
 
 # Check if we can build audio support
-CHECK_AUDIO_LIBS = $(shell pkg-config --exists $(AUDIO_LIBS) || echo -n "error")
+CHECK_AUDIO_LIBS = $(shell $(PKG_CONFIG) --exists $(AUDIO_LIBS) || echo -n "error")
 ifneq ($(CHECK_AUDIO_LIBS), error)
     LIBS += $(AUDIO_LIBS)
     CFLAGS += $(AUDIO_CFLAGS)
     OBJ += $(AUDIO_OBJ)
 else ifneq ($(MAKECMDGOALS), clean)
-    MISSING_AUDIO_LIBS = $(shell for lib in $(AUDIO_LIBS) ; do if ! pkg-config --exists $$lib ; then echo $$lib ; fi ; done)
+    MISSING_AUDIO_LIBS = $(shell for lib in $(AUDIO_LIBS) ; do if ! $(PKG_CONFIG) --exists $$lib ; then echo $$lib ; fi ; done)
     $(warning WARNING -- Toxic will be compiled without audio support)
     $(warning WARNING -- You need these libraries for audio support)
     $(warning WARNING -- $(MISSING_AUDIO_LIBS))

cfg/checks/check_features.mk

@@ -9,7 +9,17 @@ endif
 # Check if we want build audio support
 AUDIO = $(shell if [ -z "$(DISABLE_AV)" ] || [ "$(DISABLE_AV)" = "0" ] ; then echo enabled ; else echo disabled ; fi)
 ifneq ($(AUDIO), disabled)
-    -include $(CHECKS_DIR)/av.mk
+    -include $(CHECKS_DIR)/audio.mk
+endif
+
+# Check if we want build video support
+VIDEO = $(shell if [ -z "$(DISABLE_AV)" ] || [ "$(DISABLE_AV)" = "0" ] ; then echo enabled ; else echo disabled ; fi)
+ifneq ($(X11), disabled)
+ifneq ($(AUDIO), disabled)
+ifneq ($(VIDEO), disabled)
+    -include $(CHECKS_DIR)/video.mk
+endif
+endif
 endif
 
 # Check if we want build sound notifications support
@@ -24,13 +34,25 @@ ifneq ($(DESK_NOTIFY), disabled)
     -include $(CHECKS_DIR)/desktop_notifications.mk
 endif
 
+# Check if we want build QR exported as PNG support
+QR_PNG = $(shell if [ -z "$(DISABLE_QRPNG)" ] || [ "$(DISABLE_QRPNG)" = "0" ] ; then echo enabled ; else echo disabled ; fi)
+ifneq ($(QR_PNG), disabled)
+    -include $(CHECKS_DIR)/qr_png.mk
+endif
+
+# Check if we want build Python scripting support
+PYTHON = $(shell if [ -z "$(ENABLE_PYTHON)" ] || [ "$(ENABLE_PYTHON)" = "0" ] ; then echo disabled ; else echo enabled ; fi)
+ifneq ($(PYTHON), disabled)
+    -include $(CHECKS_DIR)/python.mk
+endif
+
 # Check if we can build Toxic
-CHECK_LIBS = $(shell pkg-config --exists $(LIBS) || echo -n "error")
+CHECK_LIBS = $(shell $(PKG_CONFIG) --exists $(LIBS) || echo -n "error")
 ifneq ($(CHECK_LIBS), error)
-    CFLAGS += $(shell pkg-config --cflags $(LIBS))
-    LDFLAGS += $(shell pkg-config --libs $(LIBS))
+    CFLAGS += $(shell $(PKG_CONFIG) --cflags $(LIBS))
+    LDFLAGS += $(shell $(PKG_CONFIG) --libs $(LIBS))
 else ifneq ($(MAKECMDGOALS), clean)
-    MISSING_LIBS = $(shell for lib in $(LIBS) ; do if ! pkg-config --exists $$lib ; then echo $$lib ; fi ; done)
+    MISSING_LIBS = $(shell for lib in $(LIBS) ; do if ! $(PKG_CONFIG) --exists $$lib ; then echo $$lib ; fi ; done)
     $(warning ERROR -- Cannot compile Toxic)
     $(warning ERROR -- You need these libraries)
     $(warning ERROR -- $(MISSING_LIBS))

cfg/checks/desktop_notifications.mk

@@ -3,12 +3,12 @@ DESK_NOTIFY_LIBS = libnotify
 DESK_NOTIFY_CFLAGS = -DBOX_NOTIFY
 
 # Check if we can build desktop notifications support
-CHECK_DESK_NOTIFY_LIBS = $(shell pkg-config --exists $(DESK_NOTIFY_LIBS) || echo -n "error")
+CHECK_DESK_NOTIFY_LIBS = $(shell $(PKG_CONFIG) --exists $(DESK_NOTIFY_LIBS) || echo -n "error")
 ifneq ($(CHECK_DESK_NOTIFY_LIBS), error)
     LIBS += $(DESK_NOTIFY_LIBS)
     CFLAGS += $(DESK_NOTIFY_CFLAGS)
 else ifneq ($(MAKECMDGOALS), clean)
-    MISSING_DESK_NOTIFY_LIBS = $(shell for lib in $(DESK_NOTIFY_LIBS) ; do if ! pkg-config --exists $$lib ; then echo $$lib ; fi ; done)
+    MISSING_DESK_NOTIFY_LIBS = $(shell for lib in $(DESK_NOTIFY_LIBS) ; do if ! $(PKG_CONFIG) --exists $$lib ; then echo $$lib ; fi ; done)
     $(warning WARNING -- Toxic will be compiled without desktop notifications support)
     $(warning WARNING -- You need these libraries for desktop notifications support)
     $(warning WARNING -- $(MISSING_DESK_NOTIFY_LIBS))

cfg/checks/python.mk

@@ -0,0 +1,15 @@
+# Variables for Python scripting support
+PYTHON3_LIBS = python3
+PYTHON_CFLAGS = -DPYTHON
+PYTHON_OBJ = api.o python_api.o
+
+# Check if we can build Python scripting support
+CHECK_PYTHON3_LIBS = $(shell $(PKG_CONFIG) --exists $(PYTHON3_LIBS) || echo -n "error")
+ifneq ($(CHECK_PYTHON3_LIBS), error)
+    LDFLAGS += $(shell python3-config --ldflags)
+    CFLAGS += $(PYTHON_CFLAGS) $(shell python3-config --includes)
+    OBJ += $(PYTHON_OBJ)
+else ifneq ($(MAKECMDGOALS), clean)
+    $(warning WARNING -- Toxic will be compiled without Python scripting support)
+    $(warning WARNING -- You need python3 installed for Python scripting support)
+endif

cfg/checks/qr_png.mk

@@ -0,0 +1,15 @@
+# Variables for QR exported as PNG support
+PNG_LIBS = libpng
+PNG_CFLAGS = -DQRPNG
+
+# Check if we can build QR exported as PNG support
+CHECK_PNG_LIBS = $(shell pkg-config --exists $(PNG_LIBS) || echo -n "error")
+ifneq ($(CHECK_PNG_LIBS), error)
+    LIBS += $(PNG_LIBS)
+    CFLAGS += $(PNG_CFLAGS)
+else ifneq ($(MAKECMDGOALS), clean)
+    MISSING_PNG_LIBS = $(shell for lib in $(PNG_LIBS) ; do if ! $(PKG_CONFIG) --exists $$lib ; then echo $$lib ; fi ; done)
+    $(warning WARNING -- Toxic will be compiled without QR exported as PNG support)
+    $(warning WARNING -- You need these libraries for QR exported as PNG support)
+    $(warning WARNING -- $(MISSING_PNG_LIBS))
+endif

cfg/checks/sound_notifications.mk

@@ -1,20 +1,20 @@
 # Variables for sound notifications support
 SND_NOTIFY_LIBS = openal freealut
 SND_NOTIFY_CFLAGS = -DSOUND_NOTIFY
-ifneq (, $(findstring device.o, $(OBJ)))
+ifneq (, $(findstring audio_device.o, $(OBJ)))
     SND_NOTIFY_OBJ =
 else
-    SND_NOTIFY_OBJ = device.o
+    SND_NOTIFY_OBJ = audio_device.o
 endif
 
 # Check if we can build sound notifications support
-CHECK_SND_NOTIFY_LIBS = $(shell pkg-config --exists $(SND_NOTIFY_LIBS) || echo -n "error")
+CHECK_SND_NOTIFY_LIBS = $(shell $(PKG_CONFIG) --exists $(SND_NOTIFY_LIBS) || echo -n "error")
 ifneq ($(CHECK_SND_NOTIFY_LIBS), error)
     LIBS += $(SND_NOTIFY_LIBS)
     CFLAGS += $(SND_NOTIFY_CFLAGS)
     OBJ += $(SND_NOTIFY_OBJ)
 else ifneq ($(MAKECMDGOALS), clean)
-    MISSING_SND_NOTIFY_LIBS = $(shell for lib in $(SND_NOTIFY_LIBS) ; do if ! pkg-config --exists $$lib ; then echo $$lib ; fi ; done)
+    MISSING_SND_NOTIFY_LIBS = $(shell for lib in $(SND_NOTIFY_LIBS) ; do if ! $(PKG_CONFIG) --exists $$lib ; then echo $$lib ; fi ; done)
     $(warning WARNING -- Toxic will be compiled without sound notifications support)
     $(warning WARNING -- You need these libraries for sound notifications support)
     $(warning WARNING -- $(MISSING_SND_NOTIFY_LIBS))

cfg/checks/video.mk

@@ -0,0 +1,21 @@
+# Variables for video call support
+VIDEO_LIBS = libtoxav vpx x11
+VIDEO_CFLAGS = -DVIDEO
+ifneq (, $(findstring video_device.o, $(OBJ)))
+    VIDEO_OBJ = video_call.o
+else
+    VIDEO_OBJ = video_call.o video_device.o
+endif
+
+# Check if we can build video support
+CHECK_VIDEO_LIBS = $(shell $(PKG_CONFIG) --exists $(VIDEO_LIBS) || echo -n "error")
+ifneq ($(CHECK_VIDEO_LIBS), error)
+    LIBS += $(VIDEO_LIBS)
+    CFLAGS += $(VIDEO_CFLAGS)
+    OBJ += $(VIDEO_OBJ)
+else ifneq ($(MAKECMDGOALS), clean)
+    MISSING_VIDEO_LIBS = $(shell for lib in $(VIDEO_LIBS) ; do if ! $(PKG_CONFIG) --exists $$lib ; then echo $$lib ; fi ; done)
+    $(warning WARNING -- Toxic will be compiled without video support)
+    $(warning WARNING -- You will need these libraries for video support)
+    $(warning WARNING -- $(MISSING_VIDEO_LIBS))
+endif

cfg/checks/x11.mk

@@ -4,13 +4,13 @@ X11_CFLAGS = -DX11
 X11_OBJ = xtra.o
 
 # Check if we can build X11 support
-CHECK_X11_LIBS = $(shell pkg-config --exists $(X11_LIBS) || echo -n "error")
+CHECK_X11_LIBS = $(shell $(PKG_CONFIG) --exists $(X11_LIBS) || echo -n "error")
 ifneq ($(CHECK_X11_LIBS), error)
     LIBS += $(X11_LIBS)
     CFLAGS += $(X11_CFLAGS)
     OBJ += $(X11_OBJ)
 else ifneq ($(MAKECMDGOALS), clean)
-    MISSING_X11_LIBS = $(shell for lib in $(X11_LIBS) ; do if ! pkg-config --exists $$lib ; then echo $$lib ; fi ; done)
+    MISSING_X11_LIBS = $(shell for lib in $(X11_LIBS) ; do if ! $(PKG_CONFIG) --exists $$lib ; then echo $$lib ; fi ; done)
     $(warning WARNING -- Toxic will be compiled without x11 support (needed for focus tracking and drag&drop support))
     $(warning WARNING -- You need these libraries for x11 support)
     $(warning WARNING -- $(MISSING_X11_LIBS))

cfg/global_vars.mk

@@ -1,5 +1,5 @@
 # Version
-TOXIC_VERSION = 0.6.0
+TOXIC_VERSION = 0.8.1
 REV = $(shell git rev-list HEAD --count 2>/dev/null || echo -n "error")
 ifneq (, $(findstring error, $(REV)))
     VERSION = $(TOXIC_VERSION)
@@ -16,7 +16,7 @@ MISC_DIR = $(BASE_DIR)/misc
 
 # Project files
 MANFILES = toxic.1 toxic.conf.5
-DATAFILES = DHTnodes DNSservers toxic.conf.example
+DATAFILES = nameservers toxic.conf.example
 DESKFILE = toxic.desktop
 SNDFILES = ToxicContactOnline.wav ToxicContactOffline.wav ToxicError.wav
 SNDFILES += ToxicRecvMessage.wav ToxicOutgoingCall.wav ToxicIncomingCall.wav
@@ -28,3 +28,6 @@ BINDIR = $(PREFIX)/bin
 DATADIR = $(PREFIX)/share/toxic
 MANDIR = $(PREFIX)/share/man
 APPDIR = $(PREFIX)/share/applications
+
+# Platform tools
+PKG_CONFIG = pkg-config

cfg/systems/Darwin.mk

@@ -6,5 +6,13 @@ PKG_CONFIG_PATH = $(shell export PKG_CONFIG_PATH=/usr/lib/pkgconfig:/usr/local/o
 LIBS := $(filter-out ncursesw, $(LIBS))
 
 # OS X ships a usable, recent version of ncurses, but calls it ncurses not ncursesw.
-LDFLAGS += -lncurses -lalut -ltoxav -ltoxcore -ltoxdns -lresolv -lconfig -ltoxencryptsave -g
+LDFLAGS += -lncurses -lalut -ltoxav -ltoxcore -lcurl -lconfig -ltoxencryptsave -g
 CFLAGS += -I/usr/local/opt/freealut/include/AL -I/usr/local/opt/glib/include/glib-2.0 -g
+
+OSX_LIBRARIES = -lobjc -lresolv
+OSX_FRAMEWORKS = -framework Foundation -framework CoreFoundation -framework AVFoundation \
+	-framework QuartzCore -framework CoreMedia
+OSX_VIDEO = osx_video.m
+
+LDFLAGS += $(OSX_LIBRARIES) $(OSX_FRAMEWORKS)
+OBJ += osx_video.o

cfg/systems/FreeBSD.mk

@@ -1,4 +1,4 @@
 # Specials options for freebsd systems
 LIBS := $(filter-out ncursesw, $(LIBS))
-LDFLAGS += -lncursesw
+LDFLAGS += -lncursesw -lcurl
 MANDIR = $(PREFIX)/man

cfg/systems/Linux.mk

@@ -1,4 +1,4 @@
 # Specials options for linux systems
 CFLAGS +=
-LDFLAGS += -ldl -lresolv -lrt
+LDFLAGS += -ldl -lrt -lcurl
 MANDIR = $(PREFIX)/share/man

cfg/targets/help.mk

@@ -1,18 +1,21 @@
 # Help target
 help:
 	@echo "-- Targets --"
-	@echo "  all:     Build toxic and documentation [DEFAULT]"
-	@echo "  toxic:   Build toxic"
-	@echo "  doc:     Build documentation"
-	@echo "  install: Build toxic and install it in PREFIX (default PREFIX is \"$(abspath $(PREFIX))\")"
-	@echo "  clean:   Remove built files"
-	@echo "  help:    This help"
+	@echo "  all:       Build toxic and documentation [DEFAULT]"
+	@echo "  toxic:     Build toxic"
+	@echo "  doc:       Build documentation"
+	@echo "  install:   Build toxic and install it in PREFIX (default PREFIX is \"$(abspath $(PREFIX))\")"
+	@echo "  uninstall: Remove toxic from PREFIX (default PREFIX is \"$(abspath $(PREFIX))\")"
+	@echo "  clean:     Remove built files"
+	@echo "  help:      This help"
 	@echo
 	@echo "-- Variables --"
 	@echo "  DISABLE_X11:            Set to \"1\" to force building without X11 support"
 	@echo "  DISABLE_AV:             Set to \"1\" to force building without audio call support"
 	@echo "  DISABLE_SOUND_NOTIFY:   Set to \"1\" to force building without sound notification support"
 	@echo "  DISABLE_DESKTOP_NOTIFY: Set to \"1\" to force building without desktop notifications support"
+	@echo "  DISABLE_QRPNG:          Set to \"1\" to force building without QR exported as PNG support"
+	@echo "  ENABLE_PYTHON:          Set to \"1\" to enable building with Python scripting support"
 	@echo "  USER_CFLAGS:            Add custom flags to default CFLAGS"
 	@echo "  USER_LDFLAGS:           Add custom flags to default LDFLAGS"
 	@echo "  PREFIX:                 Specify a prefix directory for binaries, data files,... (default is \"$(abspath $(PREFIX))\")"

cfg/targets/install.mk

@@ -13,7 +13,8 @@ install: $(BUILD_DIR)/toxic
 	@for f in $(DATAFILES) ; do \
 		install -m 0644 $(MISC_DIR)/$$f $(abspath $(DESTDIR)/$(DATADIR)/$$f) ;\
 		file=$(abspath $(DESTDIR)/$(DATADIR)/$$f) ;\
-		sed -i'' -e 's:__DATADIR__:'$(abspath $(DATADIR))':g' $$file ;\
+		sed -e 's:__DATADIR__:'$(abspath $(DATADIR))':g' $$file > temp_file && \
+		mv temp_file $$file ;\
 	done
 	@mkdir -p $(abspath $(DESTDIR)/$(DATADIR))/sounds
 	@for f in $(SNDFILES) ; do \
@@ -30,9 +31,11 @@ install: $(BUILD_DIR)/toxic
 		file=$$section/$$f ;\
 		mkdir -p $$section ;\
 		install -m 0644 $(DOC_DIR)/$$f $$file ;\
-		sed -i'' -e 's:__VERSION__:'$(VERSION)':g' $$file ;\
-		sed -i'' -e 's:__DATADIR__:'$(abspath $(DATADIR))':g' $$file ;\
-		gzip -f -9 $$file ;\
+		sed -e 's:__VERSION__:'$(VERSION)':g' $$file > temp_file && \
+		mv temp_file $$file ;\
+		sed -e 's:__DATADIR__:'$(abspath $(DATADIR))':g' $$file > temp_file && \
+		mv temp_file $$file ;\
+		gzip -f -n -9 $$file ;\
 	done
 
 .PHONY: install

cfg/targets/uninstall.mk

@@ -0,0 +1,24 @@
+# Uninstall target
+uninstall:
+	@echo "Removing toxic executable"
+	@rm -f $(abspath $(DESTDIR)/$(BINDIR)/toxic)
+	
+	@echo "Removing desktop file"
+	@rm -f $(abspath $(DESTDIR)/$(APPDIR)/$(DESKFILE))
+	
+	@echo "Removing data files"
+	@for f in $(DATAFILES) ; do \
+		rm -f $(abspath $(DESTDIR)/$(DATADIR)/$$f) ;\
+	done
+	@for f in $(SNDFILES) ; do \
+		rm -f $(abspath $(DESTDIR)/$(DATADIR)/sounds/$$f) ;\
+	done
+	
+	@echo "Removing man pages"
+	@for f in $(MANFILES) ; do \
+		section=$(abspath $(DESTDIR)/$(MANDIR))/man`echo $$f | rev | cut -d "." -f 1` ;\
+		file=$$section/$$f ;\
+		rm -f $$file $$file.gz ;\
+	done
+
+.PHONY: uninstall

doc/toxic.1

@@ -2,12 +2,12 @@
 .\"     Title: toxic
 .\"    Author: [see the "AUTHORS" section]
 .\" Generator: DocBook XSL Stylesheets v1.78.1 <http://docbook.sf.net/>
-.\"      Date: 2014-12-27
+.\"      Date: 2016-09-20
 .\"    Manual: Toxic Manual
 .\"    Source: toxic __VERSION__
 .\"  Language: English
 .\"
-.TH "TOXIC" "1" "2014\-12\-27" "toxic __VERSION__" "Toxic Manual"
+.TH "TOXIC" "1" "2016\-09\-20" "toxic __VERSION__" "Toxic Manual"
 .\" -----------------------------------------------------------------
 .\" * Define some portability stuff
 .\" -----------------------------------------------------------------
@@ -70,7 +70,7 @@ Encrypt an unencrypted data file\&. An error will occur if this option is used w
 Use specified
 \fIdata\-file\fR
 instead of
-\fI~/\&.config/tox/data\fR
+\fI~/\&.config/tox/toxic_profile\&.tox\fR
 .RE
 .PP
 \-h, \-\-help
@@ -82,8 +82,8 @@ Show help message
 .RS 4
 Use specified
 \fInodes\-file\fR
-for DHT bootstrap nodes, instead of
-\fI__DATADIR__/DHTnodes\fR
+for DHT bootstrap nodes instead of
+\fI~/\&.config/tox/DHTnodes\&.json\fR
 .RE
 .PP
 \-o, \-\-noconnect
@@ -101,9 +101,9 @@ Use a SOCKS5 proxy: Requires [IP] [port]
 Use a HTTP proxy: Requires [IP] [port]
 .RE
 .PP
-\-r, \-\-dnslist
+\-r, \-\-namelist
 .RS 4
-Use specified DNSservers file
+Use specified nameservers list
 .RE
 .PP
 \-t, \-\-force\-tcp
@@ -111,18 +111,25 @@ Use specified DNSservers file
 Force TCP connection (use this with proxies)
 .RE
 .PP
+\-T, \-\-tcp\-relay
+.RS 4
+Act as a TCP relay server for the network (Note: this uses significantly more bandwidth)
+.RE
+.PP
 \-u, \-\-unencrypt\-data
 .RS 4
 Unencrypt a data file\&. A warning will appear if this option is used with a data file that is already unencrypted\&.
 .RE
 .SH "FILES"
 .PP
-__DATADIR__/DHTnodes
+~/\&.config/tox/DHTnodes\&.json
 .RS 4
-Default list of DHT bootstrap nodes\&.
+Default location for list of DHT bootstrap nodes (list obtained from
+https://nodes\&.tox\&.chat)\&. This list is automatically updated\&. See
+\fBtoxic\&.conf\fR(5) for details on controlling the update frequency\&.
 .RE
 .PP
-~/\&.config/tox/data
+~/\&.config/tox/toxic_profile\&.tox
 .RS 4
 Savestate which contains your personal info (nickname, Tox ID, contacts, etc)
 .RE
@@ -139,7 +146,11 @@ Configuration example\&.
 .RE
 .SH "BUGS"
 .sp
-Unicode characters with a width larger than 1 column may cause strange behaviour\&. Expect more bugs and bad behaviour: this software is in a pre\-alpha stage\&.
+\-Unicode characters with a width larger than 1 column may cause strange behaviour\&.
+.sp
+\-Text occasionally fails to auto\-scroll to the bottom\&.
+.sp
+\-Screen flickering sometimes occurs on certain terminals\&.
 .SH "AUTHORS"
 .sp
 JFreegman <JFreegman@gmail\&.com>
@@ -148,6 +159,6 @@ JFreegman <JFreegman@gmail\&.com>
 \fBtoxic\&.conf\fR(5)
 .SH "LINKS"
 .sp
-Project page: https://github\&.com/Tox/toxic
+Project page: https://github\&.com/JFreegman/toxic
 .sp
 IRC channel: chat\&.freenode\&.net#tox

doc/toxic.1.asc

@@ -35,14 +35,13 @@ OPTIONS
     is used with an encrypted data file.
 
 -f, --file data-file::
-    Use specified 'data-file' instead of '~/.config/tox/data'
+    Use specified 'data-file' instead of '~/.config/tox/toxic_profile.tox'
 
 -h, --help::
     Show help message
 
 -n, --nodes nodes-file::
-    Use specified 'nodes-file' for DHT bootstrap nodes, instead of
-    '{datadir}/DHTnodes'
+    Use specified 'nodes-file' for DHT bootstrap nodes instead of '~/.config/tox/DHTnodes.json'
 
 -o, --noconnect::
     Do not connect to the DHT network
@@ -53,22 +52,26 @@ OPTIONS
 -P, --HTTP-proxy::
     Use a HTTP proxy: Requires [IP] [port]
 
--r, --dnslist::
-    Use specified DNSservers file
+-r, --namelist::
+    Use specified nameservers list
 
 -t, --force-tcp::
     Force TCP connection (use this with proxies)
 
+-T, --tcp-relay::
+    Act as a TCP relay server for the network (Note: this uses significantly more bandwidth)
+
 -u, --unencrypt-data::
     Unencrypt a data file. A warning will appear if this option is used
     with a data file that is already unencrypted.
 
 FILES
 -----
-{datadir}/DHTnodes::
-    Default list of DHT bootstrap nodes.
+~/.config/tox/DHTnodes.json::
+    Default location for list of DHT bootstrap nodes (list obtained from https://nodes.tox.chat).
+    This list is automatically updated. See *toxic.conf*(5) for details on controlling the update frequency.
 
-~/.config/tox/data::
+~/.config/tox/toxic_profile.tox::
     Savestate which contains your personal info (nickname, Tox ID, contacts,
     etc)
 
@@ -80,9 +83,12 @@ FILES
 
 BUGS
 ----
-Unicode characters with a width larger than 1 column may cause strange
-behaviour. Expect more bugs and bad behaviour: this software is in a
-pre-alpha stage.
+-Unicode characters with a width larger than 1 column may cause strange
+behaviour.
+
+-Text occasionally fails to auto-scroll to the bottom.
+
+-Screen flickering sometimes occurs on certain terminals.
 
 AUTHORS
 -------
@@ -94,6 +100,6 @@ SEE ALSO
 
 LINKS
 -----
-Project page: <https://github.com/Tox/toxic>
+Project page: <https://github.com/JFreegman/toxic>
 
 IRC channel: chat.freenode.net#tox

doc/toxic.conf.5

@@ -1,13 +1,13 @@
 '\" t
 .\"     Title: toxic.conf
 .\"    Author: [see the "AUTHORS" section]
-.\" Generator: DocBook XSL Stylesheets v1.78.1 <http://docbook.sf.net/>
-.\"      Date: 2015-02-26
+.\" Generator: DocBook XSL Stylesheets v1.79.1 <http://docbook.sf.net/>
+.\"      Date: 2016-09-20
 .\"    Manual: Toxic Manual
 .\"    Source: toxic __VERSION__
 .\"  Language: English
 .\"
-.TH "TOXIC\&.CONF" "5" "2015\-02\-26" "toxic __VERSION__" "Toxic Manual"
+.TH "TOXIC\&.CONF" "5" "2016\-09\-20" "toxic __VERSION__" "Toxic Manual"
 .\" -----------------------------------------------------------------
 .\" * Define some portability stuff
 .\" -----------------------------------------------------------------
@@ -85,7 +85,7 @@ Time format string for logging enclosed by double quotes\&. See
 .PP
 \fBalerts\fR
 .RS 4
-Enable or disable terminal alerts on events\&. true or false
+Enable or disable acoustic alerts on events\&. true or false
 .RE
 .PP
 \fBnative_colors\fR
@@ -113,6 +113,16 @@ Show others when you\(cqre typing in a 1\-on\-1 chat\&. true or false
 Show welcome message on startup\&. true or false
 .RE
 .PP
+\fBshow_connection_msg\fR
+.RS 4
+Enable friend connection change notifications\&. true or false
+.RE
+.PP
+\fBnodelist_update_freq\fR
+.RS 4
+How often in days to update the DHT nodes list\&. (0 to disable updates)
+.RE
+.PP
 \fBhistory_size\fR
 .RS 4
 Maximum lines for chat window history\&. Integer value\&. (for example: 700)
@@ -146,6 +156,38 @@ Set user status when attaching and detaching from GNU screen or tmux\&. true or
 \fBmplex_away_note\fR
 .RS 4
 Status message to set when status is set to away due to screen/tmux detach\&. When attaching, the status message is set back to the original value\&.
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+The following options control whether to output a terminal bell on certain events\&.
+Some terminals mark the window as urgent when a bell is received\&. Urgent windows are usually highlighted in the taskbar and some window managers even provide shortcuts to jump to the next urgent window\&.
+These options don\*(Aqt affect the "alerts" option\&.
+.fi
+.if n \{\
+.RE
+.\}
+.RE
+.PP
+\fBbell_on_message\fR
+.RS 4
+Enable/Disable the terminal bell when receiving a message\&. true or false
+.RE
+.PP
+\fBbell_on_filetrans\fR
+.RS 4
+Enable/Disable the terminal bell when receiving a filetransfer\&. true or false
+.RE
+.PP
+\fBbell_on_filetrans_accept\fR
+.RS 4
+Enable/Disable the terminal bell when a filetransfer was accepted\&. true or false
+.RE
+.PP
+\fBbell_on_invite\fR
+.RS 4
+Enable/Disable the terminal bell when receiving a group/call invite\&. true or false
 .RE
 .RE
 .PP
@@ -185,10 +227,20 @@ Default path for downloads\&. String value\&. Absolute path for downloaded files
 Path for your avatar (file must be a \&.png and cannot exceed 16\&.3 KiB)
 .RE
 .PP
+\fBautorun_path\fR
+.RS 4
+Path for any scripts that should be run on startup
+.RE
+.PP
 \fBchatlogs_path\fR
 .RS 4
 Default path for chatlogs\&. String value\&. Absolute path for chatlog files\&.
 .RE
+.PP
+\fBpassword_eval\fR
+.RS 4
+Replace password prompt by running this command and using its output as the password\&.
+.RE
 .RE
 .PP
 \fBsounds\fR
@@ -303,6 +355,11 @@ Key combination to scroll contacts list down\&.
 .RS 4
 Toggle the peer list on and off\&.
 .RE
+.PP
+\fBtoggle_paste_mode\fR
+.RS 4
+Toggle treating linebreaks as enter key press\&.
+.RE
 .RE
 .SH "FILES"
 .PP
@@ -320,7 +377,7 @@ Configuration example\&.
 \fBtoxic\fR(1)
 .SH "RESOURCES"
 .sp
-Project page: https://github\&.com/Tox/toxic
+Project page: https://github\&.com/JFreegman/toxic
 .sp
 IRC channel: chat\&.freenode\&.net#tox
 .SH "AUTHORS"

doc/toxic.conf.5.asc

@@ -55,7 +55,7 @@ OPTIONS
         See *date*(1)
 
     *alerts*;;
-        Enable or disable terminal alerts on events. true or false
+        Enable or disable acoustic alerts on events. true or false
 
     *native_colors*;;
         Select between native terminal colors and toxic color theme. true or false
@@ -72,6 +72,12 @@ OPTIONS
     *show_welcome_msg*;;
         Show welcome message on startup. true or false
 
+    *show_connection_msg*;;
+        Enable friend connection change notifications. true or false
+
+    *nodelist_update_freq*;;
+        How often in days to update the DHT nodes list. (0 to disable updates)
+
     *history_size*;;
         Maximum lines for chat window history. Integer value. (for example: 700)
 
@@ -97,6 +103,23 @@ OPTIONS
         detach. When attaching, the status message is set back to the original
         value.
 
+    The following options control whether to output a terminal bell on certain events.
+    Some terminals mark the window as urgent when a bell is received. Urgent windows are usually highlighted in the taskbar and some window managers even provide shortcuts to jump to the next urgent window.
+    These options don't affect the "alerts" option.
+
+    *bell_on_message*;;
+        Enable/Disable the terminal bell when receiving a message. true or false
+
+    *bell_on_filetrans*;;
+        Enable/Disable the terminal bell when receiving a filetransfer. true or false
+
+    *bell_on_filetrans_accept*;;
+        Enable/Disable the terminal bell when a filetransfer was accepted. true or false
+
+    *bell_on_invite*;;
+        Enable/Disable the terminal bell when receiving a group/call invite. true or false
+
+
 *audio*::
     Configuration related to audio devices.
 
@@ -120,9 +143,16 @@ OPTIONS
     *avatar_path*;;
         Path for your avatar (file must be a .png and cannot exceed 16.3 KiB)
 
+    *autorun_path*;;
+        Path for any scripts that should be run on startup
+
     *chatlogs_path*;;
         Default path for chatlogs. String value. Absolute path for chatlog files.
 
+    *password_eval*;;
+        Replace password prompt by running this command and using its output as
+	the password.
+
 *sounds*::
     Configuration related to notification sounds.
     Special value "silent" can be used to disable a specific notification. +
@@ -194,6 +224,9 @@ OPTIONS
     *toggle_peerlist*;;
         Toggle the peer list on and off.
 
+    *toggle_paste_mode*;;
+        Toggle treating linebreaks as enter key press.
+
 
 FILES
 -----
@@ -211,7 +244,7 @@ SEE ALSO
 
 RESOURCES
 ---------
-Project page: <https://github.com/Tox/toxic>
+Project page: <https://github.com/JFreegman/toxic>
 
 IRC channel:  chat.freenode.net#tox
 

misc/DHTnodes

@@ -1,20 +0,0 @@
-192.254.75.102 33445 951C88B7E75C867418ACDB5D273821372BB5BD652740BCDF623A4FA293E75D2F
-144.76.60.215 33445 04119E835DF3E78BACF0F84235B300546AF8B936F035185E2A8E9E0A67C8924F
-23.226.230.47 33445 A09162D68618E742FFBCA1C2C70385E6679604B2D80EA6E84AD0996A1AC8A074
-178.62.125.224 33445 10B20C49ACBD968D7C80F2E8438F92EA51F189F4E70CFBBB2C2C8C799E97F03E
-178.21.112.187 33445 4B2C19E924972CB9B57732FB172F8A8604DE13EEDA2A6234E348983344B23057
-195.154.119.113 33445 E398A69646B8CEACA9F0B84F553726C1C49270558C57DF5F3C368F05A7D71354
-192.210.149.121 33445 F404ABAA1C99A9D37D61AB54898F56793E1DEF8BD46B1038B9D822E8460FAB67
-104.219.184.206 443 8CD087E31C67568103E8C2A28653337E90E6B8EDA0D765D57C6B5172B4F1F04C
-76.191.23.96 33445 93574A3FAB7D612FEA29FD8D67D3DD10DFD07A075A5D62E8AF3DD9F5D0932E11
-46.38.239.179 33445 F5A1A38EFB6BD3C2C8AF8B10D85F0F89E931704D349F1D0720C3C4059AF2440A
-178.62.250.138 33445 788236D34978D1D5BD822F0A5BEBD2C53C64CC31CD3149350EE27D4D9A2F9B6B
-78.225.128.39 33445 7A2306BFBA665E5480AE59B31E116BE9C04DCEFE04D9FE25082316FA34B4DA0C
-130.133.110.14 33445 461FA3776EF0FA655F1A05477DF1B3B614F7D6B124F7DB1DD4FE3C08B03B640F
-104.167.101.29 33445 5918AC3C06955962A75AD7DF4F80A5D7C34F7DB9E1498D2E0495DE35B3FE8A57
-195.154.109.148 33445 391C96CB67AE893D4782B8E4495EB9D89CF1031F48460C06075AA8CE76D50A21
-192.3.173.88 33445 3E1FFDEB667BFF549F619EC6737834762124F50A89C8D0DBF1DDF64A2DD6CD1B
-205.185.116.116 33445 A179B09749AC826FF01F37A9613F6B57118AE014D4196A0E1105A98F93A54702
-198.98.51.198 33445 1D5A5F2F5D6233058BF0259B09622FB40B482E4FA0931EB8FD3AB8E7BF7DAF6F
-80.232.246.79 33445 0B8DCEAA7BDDC44BB11173F987CAE3566A2D7057D8DD3CC642BD472B9391002A
-

misc/DNSservers

@@ -1,2 +0,0 @@
-utox.org d3154f65d28a5b41a05d4ac7e4b39c6b1c233cc857fb365c56e8392737462a12
-toxme.se 5d72c517df6aec54f1e977a6b6f25914ea4cf7277a85027cd9f5196df17e0b13

misc/nameservers

@@ -0,0 +1 @@
+toxme.io 1A39E7A5D5FA9CF155C751570A32E625698A60A55F6D88028F949F66144F4F25

misc/toxic.conf.example

@@ -5,9 +5,21 @@ ui = {
   // true to enable timestamps, false to disable
   timestamps=true;
 
-  // true to enable terminal alerts on messages, false to disable
+  // true to enable acoustic alerts on messages, false to disable
   alerts=true;
 
+  // Output a bell when receiving a message (see manpage)
+  bell_on_message=true
+
+  // Output a bell when receiving a filetransfer (see manpage)
+  bell_on_filetrans=true
+
+  // Don't output a bell when a filetransfer was accepted (see manpage)
+  bell_on_filetrans_accept=false
+
+  // Output a bell when receiving a group/call invite (see manpage)
+  bell_on_invite=true
+
   // true to use native terminal colours, false to use toxic default colour theme
   native_colors=false;
 
@@ -17,7 +29,7 @@ ui = {
   // 24 or 12 hour time
   time_format=24;
 
-  // timestamp format string according to date/strftime format. Overrides time_format setting
+  // Timestamp format string according to date/strftime format. Overrides time_format setting
   timestamp_format="%H:%M:%S";
 
   // true to show you when others are typing a message in 1-on-1 chats
@@ -29,6 +41,12 @@ ui = {
   // true to show the welcome message on startup
   show_welcome_msg=true;
 
+  // true to show friend connection change messages on the home screen
+  show_connection_msg=true;
+
+  // How often in days to update the DHT nodes list. (0 to disable updates)
+  nodeslist_update_freq=7;
+
   // maximum lines for chat window history
   history_size=700;
 
@@ -57,7 +75,7 @@ audio = {
 
   // preferred audio output device; numbers correspond to /lsdev out
   output_device=0;
-  
+
   // default VAD treshold; float (recommended values are around 40)
   VAD_treshold=40.0;
 };
@@ -66,9 +84,12 @@ tox = {
   // Path for downloaded files
   // download_path="/home/USERNAME/Downloads/";
 
-  // Path for your avatar (file must be a .png and cannot exceed 16.3 KiB)
+  // Path for your avatar (file must be a .png and cannot exceed 64 KiB)
   // avatar_path="/home/USERNAME/Pictures/youravatar.png";
 
+  // Path for scripts that should be run on startup
+  // autorun_path="/home/USERNAME/toxic_scripts/";
+
   // Path for chatlogs
   // chatlogs_path="/home/USERNAME/toxic_chatlogs/";
 };
@@ -86,7 +107,7 @@ sounds = {
 };
 
 // Currently supported: Ctrl modified keys, Tab, PAGEUP and PAGEDOWN (case insensitive)
-// Note: All printable keys register as input
+// Note: Ctrl+M does not work
 keys = {
   next_tab="Ctrl+P";
   prev_tab="Ctrl+O";
@@ -98,5 +119,5 @@ keys = {
   peer_list_up="Ctrl+[";
   peer_list_down="Ctrl+]";
   toggle_peerlist="Ctrl+b";
+  toggle_paste_mode="Ctrl+T";
 };
-

src/api.c

@@ -0,0 +1,210 @@
+/*  api.c
+ *
+ *
+ *  Copyright (C) 2017 Jakob Kreuze <jakob@memeware.net>
+ *
+ *  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/>.
+ *
+ */
+
+#include <dirent.h>
+#include <stdint.h>
+
+#include <tox/tox.h>
+
+#include "execute.h"
+#include "friendlist.h"
+#include "line_info.h"
+#include "message_queue.h"
+#include "misc_tools.h"
+#include "settings.h"
+#include "toxic_strings.h"
+#include "windows.h"
+
+#ifdef PYTHON
+#include "python_api.h"
+#endif /* PYTHON */
+
+Tox              *user_tox;
+static WINDOW    *cur_window;
+static ToxWindow *self_window;
+
+extern FriendsList Friends;
+extern struct user_settings *user_settings;
+
+void api_display(const char *const msg)
+{
+    if (msg == NULL)
+        return;
+
+    self_window = get_active_window();
+    line_info_add(self_window, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
+}
+
+FriendsList api_get_friendslist(void)
+{
+    return Friends;
+}
+
+char *api_get_nick(void)
+{
+    size_t   len  = tox_self_get_name_size(user_tox);
+    uint8_t *name = malloc(len + 1);
+
+    if (name == NULL)
+        return NULL;
+
+    tox_self_get_name(user_tox, name);
+    name[len] = '\0';
+    return (char *) name;
+}
+
+TOX_USER_STATUS api_get_status(void)
+{
+    return tox_self_get_status(user_tox);
+}
+
+char *api_get_status_message(void)
+{
+    size_t   len    = tox_self_get_status_message_size(user_tox);
+    uint8_t *status = malloc(len + 1);
+
+    if (status == NULL)
+        return NULL;
+
+    tox_self_get_status_message(user_tox, status);
+    status[len] = '\0';
+    return (char *) status;
+}
+
+void api_send(const char *msg)
+{
+    if (msg == NULL || self_window->chatwin->cqueue == NULL)
+        return;
+
+    char *name = api_get_nick();
+    char  timefrmt[TIME_STR_SIZE];
+
+    if (name == NULL)
+        return;
+
+    self_window = get_active_window();
+    get_time_str(timefrmt, sizeof(timefrmt));
+
+    strncpy((char *) self_window->chatwin->line, msg, sizeof(self_window->chatwin->line));
+    add_line_to_hist(self_window->chatwin);
+    int id = line_info_add(self_window, timefrmt, name, NULL, OUT_MSG, 0, 0, "%s", msg);
+    cqueue_add(self_window->chatwin->cqueue, msg, strlen(msg), OUT_MSG, id);
+    free(name);
+}
+
+void api_execute(const char *input, int mode)
+{
+    self_window = get_active_window();
+    execute(cur_window, self_window, user_tox, input, mode);
+}
+
+int do_plugin_command(int num_args, char (*args)[MAX_STR_SIZE])
+{
+    return do_python_command(num_args, args);
+}
+
+int num_registered_handlers(void)
+{
+    return python_num_registered_handlers();
+}
+
+int help_max_width(void)
+{
+    return python_help_max_width();
+}
+
+void draw_handler_help(WINDOW *win)
+{
+    python_draw_handler_help(win);
+}
+
+void cmd_run(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    FILE       *fp;
+    const char *error_str;
+
+    cur_window  = window;
+    self_window = self;
+
+    if ( argc != 1 ) {
+        if ( argc < 1 ) error_str = "Path must be specified!";
+        else error_str = "Only one argument allowed!";
+
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, error_str);
+        return;
+    }
+
+    fp = fopen(argv[1], "r");
+
+    if ( fp == NULL ) {
+        error_str = "Path does not exist!";
+
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, error_str);
+        return;
+    }
+
+    run_python(fp, argv[1]);
+    fclose(fp);
+}
+
+void invoke_autoruns(WINDOW *window, ToxWindow *self)
+{
+    struct dirent *dir;
+    char    abspath_buf[PATH_MAX + 1], err_buf[PATH_MAX + 1];
+    size_t  path_len;
+    DIR    *d;
+    FILE   *fp;
+
+    if (user_settings->autorun_path[0] == '\0')
+        return;
+
+    d = opendir(user_settings->autorun_path);
+
+    if (d == NULL) {
+        snprintf(err_buf, PATH_MAX + 1, "Autorun path does not exist: %s", user_settings->autorun_path);
+        api_display(err_buf);
+        return;
+    }
+
+    cur_window  = window;
+    self_window = self;
+
+    while ((dir = readdir(d)) != NULL) {
+        path_len = strlen(dir->d_name);
+
+        if (!strcmp(dir->d_name + path_len - 3, ".py")) {
+            snprintf(abspath_buf, PATH_MAX + 1, "%s%s", user_settings->autorun_path, dir->d_name);
+            fp = fopen(abspath_buf, "r");
+
+            if (fp == NULL) {
+                snprintf(err_buf, PATH_MAX + 1, "Invalid path: %s", abspath_buf);
+                api_display(err_buf);
+                continue;
+            }
+
+            run_python(fp, abspath_buf);
+            fclose(fp);
+        }
+    }
+
+    closedir(d);
+}

src/api.h

@@ -0,0 +1,42 @@
+/*  api.h
+ *
+ *
+ *  Copyright (C) 2017 Jakob Kreuze <jakob@memeware.net>
+ *
+ *  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 API_H
+#define API_H
+
+#include "friendlist.h"
+#include "windows.h"
+
+void api_display(const char *const msg);
+FriendsList api_get_friendslist(void);
+char *api_get_nick(void);
+TOX_USER_STATUS api_get_status(void);
+char *api_get_status_message(void);
+void api_send(const char *msg);
+void api_execute(const char *input, int mode);
+int do_plugin_command(int num_args, char (*args)[MAX_STR_SIZE]);
+int num_registered_handlers(void);
+int help_max_width(void);
+void draw_handler_help(WINDOW *win);
+void invoke_autoruns(WINDOW *w, ToxWindow *self);
+
+#endif /* #define API_H */

src/audio_call.c

@@ -23,11 +23,17 @@
 #include "toxic.h"
 #include "windows.h"
 #include "audio_call.h"
-#include "device.h"
+#include "audio_device.h"
 #include "chat_commands.h"
 #include "global_commands.h"
 #include "line_info.h"
 #include "notify.h"
+#include "friendlist.h"
+#include "chat.h"
+
+#ifdef VIDEO
+#include "video_call.h"
+#endif /* VIDEO */
 
 #include <stdbool.h>
 #include <curses.h>
@@ -49,174 +55,169 @@
 #endif
 #endif
 
+extern FriendsList Friends;
+
 #define cbend pthread_exit(NULL)
 
-#define MAX_CALLS 10
+#define frame_size (CallControl.audio_sample_rate * CallControl.audio_frame_duration / 1000)
 
-#define frame_size (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000)
-
-static int set_call(Call* call, bool start)
+static int set_call(Call *call, bool start)
 {
     call->in_idx = -1;
     call->out_idx = -1;
+#ifdef VIDEO
+    call->vin_idx = -1;
+    call->vout_idx = -1;
+#endif /* VIDEO */
 
     if ( start ) {
         call->ttas = true;
 
-        if (pthread_mutex_init(&call->mutex, NULL) != 0)
+        if ( pthread_mutex_init(&call->mutex, NULL) != 0 )
             return -1;
-    }
-    else {
+    } else {
         call->ttid = 0;
-        if (pthread_mutex_destroy(&call->mutex) != 0)
+
+        if ( pthread_mutex_destroy(&call->mutex) != 0 )
             return -1;
     }
 
     return 0;
 }
 
-struct ASettings {
-    AudioError errors;
+void call_cb                 ( ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled,
+                               void *user_data );
+void callstate_cb            ( ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data );
+void receive_audio_frame_cb  ( ToxAV *av, uint32_t friend_number, int16_t const *pcm, size_t sample_count,
+                               uint8_t channels, uint32_t sampling_rate, void *user_data );
+void receive_video_frame_cb  ( ToxAV *av, uint32_t friend_number,
+                               uint16_t width, uint16_t height,
+                               uint8_t const *y, uint8_t const *u, uint8_t const *v, uint8_t const *a,
+                               int32_t ystride, int32_t ustride, int32_t vstride, int32_t astride, void *user_data );
 
-    ToxAv *av;
+void callback_recv_invite   ( Tox *m, uint32_t friend_number );
+void callback_recv_ringing  ( uint32_t friend_number );
+void callback_recv_starting ( uint32_t friend_number );
+void callback_recv_ending   ( uint32_t friend_number );
+void callback_call_started  ( uint32_t friend_number );
+void callback_call_canceled ( uint32_t friend_number );
+void callback_call_rejected ( uint32_t friend_number );
+void callback_call_ended    ( uint32_t friend_number );
 
-    ToxAvCSettings cs;
-
-    Call calls[MAX_CALLS];
-} ASettins;
-
-void callback_recv_invite   ( void* av, int32_t call_index, void *arg );
-void callback_recv_ringing  ( void* av, int32_t call_index, void *arg );
-void callback_recv_starting ( void* av, int32_t call_index, void *arg );
-void callback_recv_ending   ( void* av, int32_t call_index, void *arg );
-void callback_call_started  ( void* av, int32_t call_index, void *arg );
-void callback_call_canceled ( void* av, int32_t call_index, void *arg );
-void callback_call_rejected ( void* av, int32_t call_index, void *arg );
-void callback_call_ended    ( void* av, int32_t call_index, void *arg );
-void callback_requ_timeout  ( void* av, int32_t call_index, void *arg );
-void callback_peer_timeout  ( void* av, int32_t call_index, void *arg );
-void callback_media_change  ( void* av, int32_t call_index, void *arg );
-
-void write_device_callback( void* agent, int32_t call_index, const int16_t* PCM, uint16_t size, void* arg );
+void write_device_callback( uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
+                            uint32_t sample_rate );
 
 static void print_err (ToxWindow *self, const char *error_str)
 {
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", error_str);
 }
 
-ToxAv *init_audio(ToxWindow *self, Tox *tox)
+ToxAV *init_audio(ToxWindow *self, Tox *tox)
 {
-    ASettins.cs = av_DefaultSettings;
-    ASettins.cs.max_video_height = ASettins.cs.max_video_width = 0;
+    TOXAV_ERR_NEW error;
+    CallControl.audio_errors = ae_None;
+    CallControl.prompt = self;
+    CallControl.pending_call = false;
 
-    ASettins.errors = ae_None;
+    CallControl.av = toxav_new(tox, &error);
 
-    memset(ASettins.calls, 0, sizeof(ASettins.calls));
+    CallControl.audio_enabled = true;
+    CallControl.audio_bit_rate = 64;
+    CallControl.audio_sample_rate = 48000;
+    CallControl.audio_frame_duration = 20;
+    CallControl.audio_channels = 1;
 
+#ifndef VIDEO
+    CallControl.video_enabled = false;
+    CallControl.video_bit_rate = 0;
+    CallControl.video_frame_duration = 0;
+#endif /* VIDEO */
 
-    /* Streaming stuff from core */
+    memset(CallControl.calls, 0, sizeof(CallControl.calls));
 
-    ASettins.av = toxav_new(tox, MAX_CALLS);
+    if ( !CallControl.av ) {
+        CallControl.audio_errors |= ae_StartingCoreAudio;
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init ToxAV");
 
-    if ( !ASettins.av ) {
-        ASettins.errors |= ae_StartingCoreAudio;
         return NULL;
     }
 
-    if ( init_devices(ASettins.av) == de_InternalError ) {
+    if ( init_devices(CallControl.av) == de_InternalError ) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init devices");
-        toxav_kill(ASettins.av);
-        return ASettins.av = NULL;
+        toxav_kill(CallControl.av);
+
+        return CallControl.av = NULL;
     }
 
-    toxav_register_callstate_callback(ASettins.av, callback_call_started, av_OnStart, self);
-    toxav_register_callstate_callback(ASettins.av, callback_call_canceled, av_OnCancel, self);
-    toxav_register_callstate_callback(ASettins.av, callback_call_rejected, av_OnReject, self);
-    toxav_register_callstate_callback(ASettins.av, callback_call_ended, av_OnEnd, self);
-    toxav_register_callstate_callback(ASettins.av, callback_recv_invite, av_OnInvite, self);
+    toxav_callback_call(CallControl.av, call_cb, tox);
+    toxav_callback_call_state(CallControl.av, callstate_cb, NULL);
+    toxav_callback_audio_receive_frame(CallControl.av, receive_audio_frame_cb, NULL);
 
-    toxav_register_callstate_callback(ASettins.av, callback_recv_ringing, av_OnRinging, self);
-    toxav_register_callstate_callback(ASettins.av, callback_recv_starting, av_OnStart, self);
-    toxav_register_callstate_callback(ASettins.av, callback_recv_ending, av_OnEnd, self);
-
-    toxav_register_callstate_callback(ASettins.av, callback_requ_timeout, av_OnRequestTimeout, self);
-    toxav_register_callstate_callback(ASettins.av, callback_peer_timeout, av_OnPeerTimeout, self);
-    //toxav_register_callstate_callback(ASettins.av, callback_media_change, av_OnMediaChange, self);
-
-    toxav_register_audio_callback(ASettins.av, write_device_callback, NULL);
-
-    return ASettins.av;
+    return CallControl.av;
 }
 
 void terminate_audio()
 {
     int i;
-    for (i = 0; i < MAX_CALLS; ++i)
-        stop_transmission(&ASettins.calls[i], i);
 
-    if ( ASettins.av )
-        toxav_kill(ASettins.av);
+    for (i = 0; i < MAX_CALLS; ++i)
+        stop_transmission(&CallControl.calls[i], i);
+
+    if ( CallControl.av )
+        toxav_kill(CallControl.av);
 
     terminate_devices();
 }
 
-void read_device_callback (const int16_t* captured, uint32_t size, void* data)
+void read_device_callback(const int16_t *captured, uint32_t size, void *data)
 {
-    int32_t call_index = *((int32_t*)data); /* TODO: Or pass an array of call_idx's */
+    TOXAV_ERR_SEND_FRAME error;
+    uint32_t friend_number = *((uint32_t *)data); /* TODO: Or pass an array of call_idx's */
+    int64_t sample_count = ((int64_t) CallControl.audio_sample_rate) * \
+                           ((int64_t) CallControl.audio_frame_duration) / 1000;
 
-    uint8_t encoded_payload[RTP_PAYLOAD_SIZE];
-    int32_t payload_size = toxav_prepare_audio_frame(ASettins.av, call_index, encoded_payload, RTP_PAYLOAD_SIZE, captured, 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");*/
+    if ( sample_count <= 0 || toxav_audio_send_frame(CallControl.av, friend_number,
+            captured, sample_count,
+            CallControl.audio_channels,
+            CallControl.audio_sample_rate, &error) == false ) {
     }
 }
 
-void write_device_callback(void *agent, int32_t call_index, const int16_t* PCM, uint16_t size, void* arg)
+void write_device_callback(uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
+                           uint32_t sample_rate)
 {
-    (void)arg;
-    (void)agent;
-
-    if (call_index >= 0 && ASettins.calls[call_index].ttas) {
-        ToxAvCSettings csettings = ASettins.cs;
-        toxav_get_peer_csettings(ASettins.av, call_index, 0, &csettings);
-        write_out(ASettins.calls[call_index].out_idx, PCM, size, csettings.audio_channels);
-    }
+    if ( CallControl.calls[friend_number].ttas )
+        write_out(CallControl.calls[friend_number].out_idx, PCM, sample_count, channels, sample_rate);
 }
 
 int start_transmission(ToxWindow *self, Call *call)
 {
-    if ( !self || !ASettins.av || self->call_idx == -1 ) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Could not prepare transmission");
+    if ( !self || !CallControl.av ) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare transmission");
         return -1;
     }
 
-    /* Don't provide support for video */
-    if ( 0 != toxav_prepare_transmission(ASettins.av, self->call_idx, 0) ) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Could not prepare transmission");
-        return -1;
-    }
-
-    if ( !toxav_capability_supported(ASettins.av, self->call_idx, av_AudioDecoding) ||
-         !toxav_capability_supported(ASettins.av, self->call_idx, av_AudioEncoding) )
-        return -1;
-
     if (set_call(call, true) == -1)
         return -1;
 
-    ToxAvCSettings csettings;
-    toxav_get_peer_csettings(ASettins.av, self->call_idx, 0, &csettings);
+    DeviceError error = open_primary_device(input, &call->in_idx,
+                                            CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels);
 
-    if ( open_primary_device(input, &call->in_idx,
-            csettings.audio_sample_rate, csettings.audio_frame_duration, csettings.audio_channels) != de_None )
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open input device!");
+    if ( error != de_None ) {
+        if ( error == de_FailedStart)
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to start input device");
 
-    if ( register_device_callback(self->call_idx, call->in_idx,
-         read_device_callback, &self->call_idx, true) != de_None)
+        if ( error == de_InternalError )
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Internal error with opening input device");
+    }
+
+    if ( register_device_callback(self->num, call->in_idx,
+                                  read_device_callback, &self->num, true) != de_None)
         /* Set VAD as true for all; TODO: Make it more dynamic */
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to register input handler!");
 
     if ( open_primary_device(output, &call->out_idx,
-            csettings.audio_sample_rate, csettings.audio_frame_duration, csettings.audio_channels) != de_None ) {
+                             CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels) != de_None ) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open output device!");
         call->has_output = 0;
     }
@@ -224,22 +225,31 @@ int start_transmission(ToxWindow *self, Call *call)
     return 0;
 }
 
-int stop_transmission(Call *call, int32_t call_index)
+int stop_transmission(Call *call, uint32_t friend_number)
 {
     if ( call->ttas ) {
-        toxav_kill_transmission(ASettins.av, call_index);
-        call->ttas = false;
+        TOXAV_ERR_CALL_CONTROL error = TOXAV_ERR_CALL_CONTROL_OK;
 
-        if ( call->in_idx != -1 )
-            close_device(input, call->in_idx);
+        if ( CallControl.call_state > TOXAV_FRIEND_CALL_STATE_FINISHED )
+            toxav_call_control(CallControl.av, friend_number, TOXAV_CALL_CONTROL_CANCEL, &error);
 
-        if ( call->out_idx != -1 )
-            close_device(output, call->out_idx);
+        if ( error == TOXAV_ERR_CALL_CONTROL_OK ) {
+            call->ttas = false;
+
+            if ( call->in_idx != -1 )
+                close_device(input, call->in_idx);
+
+            if ( call->out_idx != -1 )
+                close_device(output, call->out_idx);
+
+            if ( set_call(call, false) == -1 )
+                return -1;
+
+            return 0;
+        } else {
 
-        if (set_call(call, false) == -1)
             return -1;
-
-        return 0;
+        }
     }
 
     return -1;
@@ -255,85 +265,195 @@ int stop_transmission(Call *call, int32_t call_index)
 /*
  * 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 ( void* av, int32_t call_index, void* arg )
+void call_cb(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data)
 {
-    CB_BODY(call_index, arg, onInvite);
+    Tox *m = (Tox *) user_data;
+    CallControl.pending_call = true;
+    callback_recv_invite(m, friend_number);
 }
-void callback_recv_ringing ( void* av, int32_t call_index, void* arg )
+
+void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data)
 {
-    CB_BODY(call_index, arg, onRinging);
-}
-void callback_recv_starting ( void* av, 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_idx == call_index) {
-            windows[i].onStarting(&windows[i], ASettins.av, call_index);
-            if ( 0 != start_transmission(&windows[i], &ASettins.calls[call_index])) {/* YEAH! */
-                line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0 , "Error starting transmission!");
+    CallControl.call_state = state;
+
+    switch ( state ) {
+        case ( TOXAV_FRIEND_CALL_STATE_ERROR ):
+            line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "ToxAV callstate error!");
+
+#ifdef VIDEO
+            callback_video_end(friend_number);
+#endif /* VIDEO */
+
+            stop_transmission(&CallControl.calls[friend_number], friend_number);
+            callback_call_ended(friend_number);
+            CallControl.pending_call = false;
+
+            break;
+
+        case ( TOXAV_FRIEND_CALL_STATE_FINISHED ):
+            if ( CallControl.pending_call )
+                callback_call_rejected(friend_number);
+            else
+                callback_call_ended(friend_number);
+
+#ifdef VIDEO
+            callback_recv_video_end(friend_number);
+            callback_video_end(friend_number);
+#endif /* VIDEO */
+
+            stop_transmission(&CallControl.calls[friend_number], friend_number);
+
+            /* Reset stored call state after finishing */
+            CallControl.call_state = 0;
+            CallControl.pending_call = false;
+
+            break;
+
+        default:
+            if ( CallControl.pending_call ) {
+                /* Start answered call */
+                callback_call_started(friend_number);
+                CallControl.pending_call = false;
+
+            } else {
+#ifdef VIDEO
+
+                /* Handle receiving client video call states */
+                if ( state & TOXAV_FRIEND_CALL_STATE_SENDING_V )
+                    callback_recv_video_starting(friend_number);
+                else if ( state & ~TOXAV_FRIEND_CALL_STATE_SENDING_V )
+                    callback_recv_video_end(friend_number);
+
+#endif /* VIDEO */
             }
+
+            break;
+    }
+}
+
+void receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
+                            int16_t const *pcm, size_t sample_count,
+                            uint8_t channels, uint32_t sampling_rate, void *user_data)
+{
+    write_device_callback(friend_number, pcm, sample_count, channels, sampling_rate);
+}
+
+void audio_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate,
+                              uint32_t video_bit_rate, void *user_data)
+{
+    CallControl.audio_bit_rate = audio_bit_rate;
+    toxav_bit_rate_set(av, friend_number, audio_bit_rate, video_bit_rate, user_data);
+}
+
+void callback_recv_invite(Tox *m, uint32_t friend_number)
+{
+    if (friend_number >= Friends.max_idx)
+        return;
+
+    if (Friends.list[friend_number].chatwin == -1) {
+        if (get_num_active_windows() >= MAX_WINDOWS_NUM)
+            return;
+
+        Friends.list[friend_number].chatwin = add_window(m, new_chat(m, Friends.list[friend_number].num));
+    }
+
+    ToxWindow *windows = CallControl.prompt;
+    int i;
+
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].onInvite != NULL && windows[i].num == friend_number) {
+            windows[i].onInvite(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+        }
+    }
+}
+void callback_recv_ringing(uint32_t friend_number)
+{
+    ToxWindow *windows = CallControl.prompt;
+    int i;
+
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].onRinging != NULL && windows[i].num == friend_number) {
+            windows[i].onRinging(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+        }
+    }
+}
+void callback_recv_starting(uint32_t friend_number)
+{
+    ToxWindow *windows = CallControl.prompt;
+
+    int i;
+
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if ( windows[i].onStarting != NULL && windows[i].num == friend_number ) {
+            windows[i].onStarting(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+
+            if ( 0 != start_transmission(&windows[i], &CallControl.calls[friend_number]) ) /* YEAH! */
+                line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
+
             return;
         }
+    }
 }
-void callback_recv_ending ( void* av, int32_t call_index, void* arg )
+void callback_recv_ending(uint32_t friend_number)
 {
-    CB_BODY(call_index, arg, onEnding);
-    stop_transmission(&ASettins.calls[call_index], call_index);
-}
-
-void callback_call_started ( void* av, int32_t call_index, void* arg )
-{
-    ToxWindow* windows = arg;
+    ToxWindow *windows = CallControl.prompt;
     int i;
+
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].onEnding != NULL && windows[i].num == friend_number) {
+            windows[i].onEnding(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+        }
+    }
+}
+void callback_call_started(uint32_t friend_number)
+{
+    ToxWindow *windows = CallControl.prompt;
+
+    int i;
+
     for (i = 0; i < MAX_WINDOWS_NUM; ++i)
-        if (windows[i].onStart != NULL && windows[i].call_idx == call_index) {
-            windows[i].onStart(&windows[i], ASettins.av, call_index);
-            if ( 0 != start_transmission(&windows[i], &ASettins.calls[call_index]) ) {/* YEAH! */
+        if ( windows[i].onStart != NULL && windows[i].num == friend_number ) {
+            windows[i].onStart(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+
+            if ( 0 != start_transmission(&windows[i], &CallControl.calls[friend_number]) ) {/* YEAH! */
                 line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
                 return;
             }
         }
 }
-void callback_call_canceled ( void* av, int32_t call_index, void* arg )
+void callback_call_canceled(uint32_t friend_number)
 {
-    CB_BODY(call_index, arg, onCancel);
+    ToxWindow *windows = CallControl.prompt;
+    int i;
 
-    /* In case call is active */
-    stop_transmission(&ASettins.calls[call_index], call_index);
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].onCancel != NULL && windows[i].num == friend_number) {
+            windows[i].onCancel(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+        }
+    }
 }
-void callback_call_rejected ( void* av, int32_t call_index, void* arg )
+void callback_call_rejected(uint32_t friend_number)
 {
-    CB_BODY(call_index, arg, onReject);
-}
-void callback_call_ended ( void* av, int32_t call_index, void* arg )
-{
-    CB_BODY(call_index, arg, onEnd);
-    stop_transmission(&ASettins.calls[call_index], call_index);
-}
+    ToxWindow *windows = CallControl.prompt;
+    int i;
 
-void callback_requ_timeout ( void* av, int32_t call_index, void* arg )
-{
-    CB_BODY(call_index, arg, onRequestTimeout);
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].onReject != NULL && windows[i].num == friend_number) {
+            windows[i].onReject(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+        }
+    }
 }
-void callback_peer_timeout ( void* av, int32_t call_index, void* arg )
+void callback_call_ended(uint32_t friend_number)
 {
-    CB_BODY(call_index, arg, onPeerTimeout);
-    stop_transmission(&ASettins.calls[call_index], 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);
-}
+    ToxWindow *windows = CallControl.prompt;
+    int i;
 
-// void callback_media_change(void* av, int32_t call_index, void* arg)
-// {
-  /*... TODO cancel all media change requests */
-// }
+    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        if (windows[i].onEnd != NULL && windows[i].num == friend_number) {
+            windows[i].onEnd(&windows[i], CallControl.av, friend_number, CallControl.call_state);
+        }
+    }
+}
 
 /*
  * End of Callbacks
@@ -345,33 +465,43 @@ void callback_peer_timeout ( void* av, int32_t call_index, void* arg )
  */
 void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    TOXAV_ERR_CALL error;
     const char *error_str;
 
-    if (argc != 0) {
+    if ( argc != 0 ) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !ASettins.av ) {
-        error_str = "Audio not supported!";
+    if ( !CallControl.av ) {
+        error_str = "ToxAV not supported!";
         goto on_error;
     }
 
-    if (!self->stb->connection) {
+    if ( !self->stb->connection ) {
         error_str = "Friend is offline.";
         goto on_error;
     }
 
-    ToxAvError error = toxav_call(ASettins.av, &self->call_idx, self->num, &ASettins.cs, 30);
+    if ( CallControl.pending_call ) {
+        error_str = "Already a pending call!";
+        goto on_error;
+    }
 
-    if ( error != av_ErrorNone ) {
-        if ( error == av_ErrorAlreadyInCallWithPeer ) error_str = "Already in a call!";
+    toxav_call(CallControl.av, self->num, CallControl.audio_bit_rate, CallControl.video_bit_rate, &error);
+
+    if ( error != TOXAV_ERR_CALL_OK ) {
+        if ( error == TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL ) error_str = "Already in a call!";
+        else if ( error == TOXAV_ERR_CALL_MALLOC ) error_str = "Memory allocation issue";
+        else if ( error == TOXAV_ERR_CALL_FRIEND_NOT_FOUND ) error_str = "Friend number invalid";
+        else if ( error == TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED ) error_str = "Friend is valid but not currently connected";
         else error_str = "Internal error!";
 
         goto on_error;
     }
 
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Calling... idx: %d", self->call_idx);
+    CallControl.pending_call = true;
+    callback_recv_ringing(self->num);
 
     return;
 on_error:
@@ -380,29 +510,39 @@ on_error:
 
 void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    TOXAV_ERR_ANSWER error;
     const char *error_str;
 
-    if (argc != 0) {
+    if ( argc != 0 ) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !ASettins.av ) {
+    if ( !CallControl.av ) {
         error_str = "Audio not supported!";
         goto on_error;
     }
 
-    ToxAvError error = toxav_answer(ASettins.av, self->call_idx, &ASettins.cs);
+    if ( !CallControl.pending_call ) {
+        error_str = "No incoming call!";
+        goto on_error;
+    }
 
-    if ( error != av_ErrorNone ) {
-        if ( error == av_ErrorInvalidState ) error_str = "Cannot answer in invalid state!";
-        else if ( error == av_ErrorNoCall ) error_str = "No incoming call!";
+    toxav_answer(CallControl.av, self->num, CallControl.audio_bit_rate, CallControl.video_bit_rate, &error);
+
+    if ( error != TOXAV_ERR_ANSWER_OK ) {
+        if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING ) error_str = "No incoming call!";
+        else if ( error == TOXAV_ERR_ANSWER_CODEC_INITIALIZATION ) error_str = "Failed to initialize codecs!";
+        else if ( error == TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND ) error_str = "Friend not found!";
+        else if ( error == TOXAV_ERR_ANSWER_INVALID_BIT_RATE ) error_str = "Invalid bit rate!";
         else error_str = "Internal error!";
 
         goto on_error;
     }
 
     /* Callback will print status... */
+    callback_recv_starting(self->num);
+    CallControl.pending_call = false;
 
     return;
 on_error:
@@ -413,27 +553,27 @@ void cmd_reject(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
 {
     const char *error_str;
 
-    if (argc != 0) {
+    if ( argc != 0 ) {
         error_str = "Unknown arguments.";
         goto on_error;
     }
 
-    if ( !ASettins.av ) {
+    if ( !CallControl.av ) {
         error_str = "Audio not supported!";
         goto on_error;
     }
 
-    ToxAvError error = toxav_reject(ASettins.av, self->call_idx, "Why not?");
-
-    if ( error != av_ErrorNone ) {
-        if ( error == av_ErrorInvalidState ) error_str = "Cannot reject in invalid state!";
-        else if ( error == av_ErrorNoCall ) error_str = "No incoming call!";
-        else error_str = "Internal error!";
-
+    if ( !CallControl.pending_call ) {
+        error_str = "No incoming call!";
         goto on_error;
     }
 
+    /* Manually send a cancel call control because call hasn't started */
+    toxav_call_control(CallControl.av, self->num, TOXAV_CALL_CONTROL_CANCEL, NULL);
+    CallControl.pending_call = false;
+
     /* Callback will print status... */
+    callback_call_rejected(self->num);
 
     return;
 on_error:
@@ -442,39 +582,28 @@ on_error:
 
 void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    const char *error_str;
+    const char *error_str = NULL;
 
-    if (argc != 0) {
-        error_str = "Unknown arguments.";
-        goto on_error;
-    }
-
-    if ( !ASettins.av ) {
+    if ( !CallControl.av ) {
         error_str = "Audio not supported!";
         goto on_error;
     }
 
-    ToxAvError error;
-
-    if (toxav_get_call_state(ASettins.av, self->call_idx) == av_CallInviting) {
-        error = toxav_cancel(ASettins.av, self->call_idx, self->num,
-                                        "Only those who appreciate small things know the beauty that is life");
-#ifdef SOUND_NOTIFY
-        stop_sound(self->ringing_sound);
-#endif
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call canceled!");
-    } else {
-        error = toxav_hangup(ASettins.av, self->call_idx);
-    }
-
-    if ( error != av_ErrorNone ) {
-        if ( error == av_ErrorInvalidState ) error_str = "Cannot hangup in invalid state!";
-        else if ( error == av_ErrorNoCall ) error_str = "No call!";
-        else error_str = "Internal error!";
-
+    if ( argc != 0 ) {
+        error_str = "Unknown arguments.";
         goto on_error;
     }
 
+    if ( !self->is_call && !CallControl.pending_call ) {
+        error_str = "Not in a call.";
+        goto on_error;
+    }
+
+#ifdef VIDEO
+    callback_video_end(self->num);
+#endif /* VIDEO */
+
+    stop_current_call(self);
     return;
 on_error:
     print_err (self, error_str);
@@ -504,6 +633,9 @@ void cmd_list_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*
         return;
     }
 
+    // Refresh device list.
+    get_devices_names();
+
     print_devices(self, type);
 
     return;
@@ -547,7 +679,7 @@ void cmd_change_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (
     }
 
     if ( set_primary_device(type, selection) == de_InvalidSelection ) {
-        error_str="Invalid selection!";
+        error_str = "Invalid selection!";
         goto on_error;
     }
 
@@ -591,33 +723,31 @@ void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
     }
 
     if ( selection_valid(type, selection) == de_InvalidSelection ) {
-        error_str="Invalid selection!";
+        error_str = "Invalid selection!";
         goto on_error;
     }
 
     /* If call is active, change device */
-    if ( self->call_idx > -1) {
-        Call* this_call = &ASettins.calls[self->call_idx];
-        if (this_call->ttas) {
+    if ( self->is_call ) {
+        Call *this_call = &CallControl.calls[self->num];
 
-            ToxAvCSettings csettings;
-            toxav_get_peer_csettings(ASettins.av, self->call_idx, 0, &csettings);
+        if ( this_call->ttas ) {
 
-            if (type == output) {
+
+            if ( type == output ) {
                 pthread_mutex_lock(&this_call->mutex);
                 close_device(output, this_call->out_idx);
                 this_call->has_output = open_device(output, selection, &this_call->out_idx,
-                    csettings.audio_sample_rate, csettings.audio_frame_duration, csettings.audio_channels)
-                    == de_None ? 1 : 0;
+                                                    CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels)
+                                        == de_None ? 1 : 0;
                 pthread_mutex_unlock(&this_call->mutex);
-            }
-            else {
+            } else {
                 /* TODO: check for failure */
                 close_device(input, this_call->in_idx);
-                open_device(input, selection, &this_call->in_idx, csettings.audio_sample_rate,
-                    csettings.audio_frame_duration, csettings.audio_channels);
+                open_device(input, selection, &this_call->in_idx, CallControl.audio_sample_rate,
+                            CallControl.audio_frame_duration, CallControl.audio_channels);
                 /* Set VAD as true for all; TODO: Make it more dynamic */
-                register_device_callback(self->call_idx, this_call->in_idx, read_device_callback, &self->call_idx, true);
+                register_device_callback(self->num, this_call->in_idx, read_device_callback, &self->num, true);
             }
         }
     }
@@ -625,7 +755,7 @@ void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
     self->device_selection[type] = selection;
 
     return;
-    on_error:
+on_error:
     print_err (self, error_str);
 }
 
@@ -655,23 +785,25 @@ void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
 
 
     /* If call is active, use this_call values */
-    if ( self->call_idx > -1) {
-        Call* this_call = &ASettins.calls[self->call_idx];
+    if ( self->is_call ) {
+        Call *this_call = &CallControl.calls[self->num];
 
         pthread_mutex_lock(&this_call->mutex);
-        if (type == input) {
+
+        if ( type == input ) {
             device_mute(type, this_call->in_idx);
             self->chatwin->infobox.in_is_muted ^= 1;
         } else {
             device_mute(type, this_call->out_idx);
             self->chatwin->infobox.out_is_muted ^= 1;
         }
+
         pthread_mutex_unlock(&this_call->mutex);
     }
 
     return;
 
-    on_error:
+on_error:
     print_err (self, error_str);
 }
 
@@ -695,8 +827,8 @@ void cmd_sense(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[M
     }
 
     /* Call must be active */
-    if ( self->call_idx > -1) {
-        device_set_VAD_treshold(ASettins.calls[self->call_idx].in_idx, value);
+    if ( self->is_call ) {
+        device_set_VAD_treshold(CallControl.calls[self->num].in_idx, value);
         self->chatwin->infobox.vad_lvl = value;
     }
 
@@ -706,26 +838,65 @@ on_error:
     print_err (self, error_str);
 }
 
-
-void stop_current_call(ToxWindow* self)
+void cmd_bitrate(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    ToxAvCallState callstate;
-    if ( ASettins.av != NULL && self->call_idx != -1 &&
-       ( callstate = toxav_get_call_state(ASettins.av, self->call_idx) ) != av_CallNonExistent) {
-        switch (callstate)
-        {
-        case av_CallActive:
-        case av_CallHold:
-            toxav_hangup(ASettins.av, self->call_idx);
-            break;
-        case av_CallInviting:
-            toxav_cancel(ASettins.av, self->call_idx, 0, "Not interested anymore");
-            break;
-        case av_CallStarting:
-            toxav_reject(ASettins.av, self->call_idx, "Not interested");
-            break;
-        default:
-            break;
-        }
+    char *error_str;
+
+    if ( argc != 1 ) {
+        error_str = "Must have value!";
+        goto on_error;
     }
+
+    if ( self->is_call == false ) {
+        error_str = "Must be in a call";
+        goto on_error;
+    }
+
+    const uint32_t bitrate = strtol(argv[1], NULL, 10);
+
+    TOXAV_ERR_BIT_RATE_SET error;
+    audio_bit_rate_status_cb(CallControl.av, self->num, bitrate, -1, &error);
+
+    if (error != TOXAV_ERR_BIT_RATE_SET_OK) {
+        switch (error) {
+            case TOXAV_ERR_BIT_RATE_SET_SYNC:
+                error_str = "Syncronization error occured";
+                break;
+
+            case TOXAV_ERR_BIT_RATE_SET_INVALID_AUDIO_BIT_RATE:
+                error_str = "Invalid audio bit rate value (valid is 6-510)";
+                break;
+
+            case TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND:
+                error_str = "Friend not found";
+                break;
+
+            case TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL:
+                error_str = "Friend is not in the call";
+                break;
+
+            default:
+                error_str = "Unknown error";
+        }
+
+        goto on_error;
+    }
+
+    return;
+
+on_error:
+    print_err (self, error_str);
+}
+
+void stop_current_call(ToxWindow *self)
+{
+    if ( CallControl.pending_call ) {
+        toxav_call_control(CallControl.av, self->num, TOXAV_CALL_CONTROL_CANCEL, NULL);
+        callback_call_canceled(self->num);
+    } else {
+        stop_transmission(&CallControl.calls[self->num], self->num);
+        callback_call_ended(self->num);
+    }
+
+    CallControl.pending_call = false;
 }

src/audio_call.h

@@ -20,12 +20,14 @@
  *
  */
 
-#ifndef AUDIO_H
-#define AUDIO_H
+#ifndef AUDIO_CALL_H
+#define AUDIO_CALL_H
 
 #include <tox/toxav.h>
 
-#include "device.h"
+#include "audio_device.h"
+
+#define MAX_CALLS 10
 
 typedef enum _AudioError {
     ae_None = 0,
@@ -34,18 +36,58 @@ typedef enum _AudioError {
     ae_StartingCoreAudio = 1 << 2
 } AudioError;
 
+#ifdef VIDEO
+typedef enum _VideoError {
+    ve_None = 0,
+    ve_StartingCaptureDevice = 1 << 0,
+    ve_StartingOutputDevice = 1 << 1,
+    ve_StartingCoreVideo = 1 << 2
+} VideoError;
+
+#endif /* VIDEO */
+
 typedef struct Call {
     pthread_t ttid; /* Transmission thread id */
     bool ttas, has_output; /* Transmission thread active status (0 - stopped, 1- running) */
-    uint32_t in_idx, out_idx;
+    uint32_t in_idx, out_idx; /* Audio Index */
+#ifdef VIDEO
+    uint32_t vin_idx, vout_idx; /* Video Index */
+#endif /* VIDEO */
     pthread_mutex_t mutex;
 } Call;
 
+struct CallControl {
+    AudioError audio_errors;
+#ifdef VIDEO
+    VideoError video_errors;
+#endif /* VIDEO */
+
+    ToxAV *av;
+    ToxWindow *prompt;
+
+    Call calls[MAX_CALLS];
+    uint32_t call_state;
+    bool pending_call;
+    bool audio_enabled;
+    bool video_enabled;
+
+    uint32_t audio_bit_rate;
+    int32_t audio_frame_duration;
+    uint32_t audio_sample_rate;
+    uint8_t audio_channels;
+
+    uint32_t video_bit_rate;
+    int32_t video_frame_duration;
+
+} CallControl;
+
+struct CallControl CallControl;
+
 /* You will have to pass pointer to first member of 'windows' declared in windows.c */
-ToxAv *init_audio(ToxWindow *self, Tox *tox);
+ToxAV *init_audio(ToxWindow *self, Tox *tox);
 void terminate_audio();
 int start_transmission(ToxWindow *self, Call *call);
-int stop_transmission(Call *call, int call_index);
+int stop_transmission(Call *call, uint32_t friend_number);
 void stop_current_call(ToxWindow *self);
 
-#endif /* AUDIO_H */
+#endif /* AUDIO_CALL_H */

src/audio_device.c

@@ -1,4 +1,4 @@
-/*  device.c
+/*  audio_device.c
  *
  *
  *  Copyright (C) 2014 Toxic All Rights Reserved.
@@ -20,7 +20,7 @@
  *
  */
 
-#include "device.h"
+#include "audio_device.h"
 
 #ifdef AUDIO
 #include "audio_call.h"
@@ -56,16 +56,16 @@ typedef struct Device {
     ALCdevice  *dhndl;                     /* Handle of device selected/opened */
     ALCcontext *ctx;                       /* Device context */
     DataHandleCallback cb;                 /* Use this to handle data from input device usually */
-    void* cb_data;                         /* Data to be passed to callback */
-    int32_t call_idx;                      /* ToxAv call index */
-    
+    void *cb_data;                         /* Data to be passed to callback */
+    int32_t friend_number;                      /* ToxAV friend number */
+
     uint32_t source, buffers[OPENAL_BUFS]; /* Playback source/buffers */
     uint32_t ref_count;
     int32_t selection;
     bool enable_VAD;
     bool muted;
     pthread_mutex_t mutex[1];
-    uint32_t sample_rate; 
+    uint32_t sample_rate;
     uint32_t frame_duration;
     int32_t sound_mode;
 #ifdef AUDIO
@@ -80,7 +80,7 @@ Device *running[2][MAX_DEVICES] = {{NULL}};     /* Running devices */
 uint32_t primary_device[2];          /* Primary device */
 
 #ifdef AUDIO
-static ToxAv* av = NULL;
+static ToxAV *av = NULL;
 #endif /* AUDIO */
 
 /* q_mutex */
@@ -89,80 +89,97 @@ static ToxAv* av = NULL;
 pthread_mutex_t mutex;
 
 
-bool thread_running = true, 
-      thread_paused = true;               /* Thread control */
+bool thread_running = true,
+     thread_paused = true;               /* Thread control */
 
-void* thread_poll(void*);
+void *thread_poll(void *);
 /* Meet devices */
 #ifdef AUDIO
-DeviceError init_devices(ToxAv* av_)
+DeviceError init_devices(ToxAV *av_)
 #else
 DeviceError init_devices()
 #endif /* AUDIO */
 {
-    const char *stringed_device_list;
-
-    size[input] = 0;
-    if ( (stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER)) ) {
-        ddevice_names[input] = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
-        
-        for ( ; *stringed_device_list && size[input] < MAX_DEVICES; ++size[input] ) {
-            devices_names[input][size[input]] = stringed_device_list;                        
-            stringed_device_list += strlen( stringed_device_list ) + 1;
-        }
-    }
-    
-    size[output] = 0;
-    if ( (stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER)) ) {
-        ddevice_names[output] = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
-        
-        for ( ; *stringed_device_list && size[output] < MAX_DEVICES; ++size[output] ) {
-            devices_names[output][size[output]] = stringed_device_list;            
-            stringed_device_list += strlen( stringed_device_list ) + 1;
-        }
-    }
+    get_devices_names();
 
     // Start poll thread
     if (pthread_mutex_init(&mutex, NULL) != 0)
         return de_InternalError;
-    
+
     pthread_t thread_id;
-    if ( pthread_create(&thread_id, NULL, thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0) 
-        return de_InternalError;    
-    
+
+    if ( pthread_create(&thread_id, NULL, thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0)
+        return de_InternalError;
+
 #ifdef AUDIO
     av = av_;
 #endif /* AUDIO */
-    
+
     return (DeviceError) de_None;
 }
 
 DeviceError terminate_devices()
 {
     /* Cleanup if needed */
+    lock;
     thread_running = false;
+    unlock;
+
     usleep(20000);
-    
+
     if (pthread_mutex_destroy(&mutex) != 0)
         return (DeviceError) de_InternalError;
-    
+
     return (DeviceError) de_None;
 }
 
+void get_devices_names() {
+
+    const char *stringed_device_list;
+
+    size[input] = 0;
+
+    if ( (stringed_device_list = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER)) ) {
+        ddevice_names[input] = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+
+        for ( ; *stringed_device_list && size[input] < MAX_DEVICES; ++size[input] ) {
+            devices_names[input][size[input]] = stringed_device_list;
+            stringed_device_list += strlen( stringed_device_list ) + 1;
+        }
+    }
+
+    size[output] = 0;
+
+    if (alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE)
+        stringed_device_list = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
+    else
+        stringed_device_list = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+
+    if (stringed_device_list) {
+        ddevice_names[output] = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+
+        for ( ; *stringed_device_list && size[output] < MAX_DEVICES; ++size[output] ) {
+            devices_names[output][size[output]] = stringed_device_list;
+            stringed_device_list += strlen( stringed_device_list ) + 1;
+        }
+    }
+}
+
 DeviceError device_mute(DeviceType type, uint32_t device_idx)
 {
     if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
+
     lock;
-    
-    Device* device = running[type][device_idx];
-    
-    if (!device) { 
+
+    Device *device = running[type][device_idx];
+
+    if (!device) {
         unlock;
         return de_DeviceNotActive;
     }
-    
+
     device->muted = !device->muted;
-    
+
     unlock;
     return de_None;
 }
@@ -171,11 +188,12 @@ DeviceError device_mute(DeviceType type, uint32_t device_idx)
 DeviceError device_set_VAD_treshold(uint32_t device_idx, float value)
 {
     if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
+
     lock;
 
-    Device* device = running[input][device_idx];
+    Device *device = running[input][device_idx];
 
-    if (!device) { 
+    if (!device) {
         unlock;
         return de_DeviceNotActive;
     }
@@ -191,12 +209,14 @@ DeviceError device_set_VAD_treshold(uint32_t device_idx, float value)
 DeviceError set_primary_device(DeviceType type, int32_t selection)
 {
     if (size[type] <= selection || selection < 0) return de_InvalidSelection;
+
     primary_device[type] = selection;
-    
+
     return de_None;
 }
 
-DeviceError open_primary_device(DeviceType type, uint32_t* device_idx, uint32_t sample_rate, uint32_t frame_duration, uint8_t channels)
+DeviceError open_primary_device(DeviceType type, uint32_t *device_idx, uint32_t sample_rate, uint32_t frame_duration,
+                                uint8_t channels)
 {
     return open_device(type, primary_device[type], device_idx, sample_rate, frame_duration, channels);
 }
@@ -207,93 +227,97 @@ void get_primary_device_name(DeviceType type, char *buf, int size)
 }
 
 // TODO: generate buffers separately
-DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx, uint32_t sample_rate, uint32_t frame_duration, uint8_t channels)
+DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx, uint32_t sample_rate,
+                        uint32_t frame_duration, uint8_t channels)
 {
     if (size[type] <= selection || selection < 0) return de_InvalidSelection;
 
     if (channels != 1 && channels != 2) return de_UnsupportedMode;
-    
+
     lock;
 
     const uint32_t frame_size = (sample_rate * frame_duration / 1000);
-    
+
     uint32_t i;
+
     for (i = 0; i < MAX_DEVICES && running[type][i] != NULL; ++i);
-    
-    if (i == MAX_DEVICES) { unlock; return de_AllDevicesBusy; }
-    else *device_idx = i;
-    
+
+    if (i == MAX_DEVICES) {
+        unlock;
+        return de_AllDevicesBusy;
+    } else *device_idx = i;
+
     for (i = 0; i < MAX_DEVICES; i ++) { /* Check if any device has the same selection */
         if ( running[type][i] && running[type][i]->selection == selection ) {
 //             printf("a%d-%d:%p ", selection, i, running[type][i]->dhndl);
-            
-            running[type][*device_idx] = running[type][i];            
+
+            running[type][*device_idx] = running[type][i];
             running[type][i]->ref_count ++;
-            
+
             unlock;
             return de_None;
         }
     }
-    
-    Device* device = running[type][*device_idx] = calloc(1, sizeof(Device));
+
+    Device *device = running[type][*device_idx] = calloc(1, sizeof(Device));
     device->selection = selection;
-    
+
     device->sample_rate = sample_rate;
     device->frame_duration = frame_duration;
     device->sound_mode = channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
-    
+
     if (pthread_mutex_init(device->mutex, NULL) != 0) {
         free(device);
         unlock;
         return de_InternalError;
     }
-    
+
     if (type == input) {
-        device->dhndl = alcCaptureOpenDevice(devices_names[type][selection], 
+        device->dhndl = alcCaptureOpenDevice(devices_names[type][selection],
                                              sample_rate, device->sound_mode, frame_size * 2);
-    #ifdef AUDIO
+#ifdef AUDIO
         device->VAD_treshold = user_settings->VAD_treshold;
-    #endif
-    }
-    else { 
+#endif
+    } else {
         device->dhndl = alcOpenDevice(devices_names[type][selection]);
-        if ( !device->dhndl ) { 
+
+        if ( !device->dhndl ) {
             free(device);
             running[type][*device_idx] = NULL;
             unlock;
             return de_FailedStart;
         }
-        
+
         device->ctx = alcCreateContext(device->dhndl, NULL);
         alcMakeContextCurrent(device->ctx);
-        
+
         alGenBuffers(OPENAL_BUFS, device->buffers);
         alGenSources((uint32_t)1, &device->source);
         alSourcei(device->source, AL_LOOPING, AL_FALSE);
-        
+
         uint16_t zeros[frame_size];
-        memset(zeros, 0, frame_size*2);
-        
+        memset(zeros, 0, frame_size * 2);
+
         for ( i = 0; i < OPENAL_BUFS; ++i ) {
-            alBufferData(device->buffers[i], device->sound_mode, zeros, frame_size*2, sample_rate);
+            alBufferData(device->buffers[i], device->sound_mode, zeros, frame_size * 2, sample_rate);
         }
-        
+
         alSourceQueueBuffers(device->source, OPENAL_BUFS, device->buffers);
         alSourcePlay(device->source);
     }
-    
+
     if (alcGetError(device->dhndl) != AL_NO_ERROR) {
         free(device);
         running[type][*device_idx] = NULL;
         unlock;
         return de_FailedStart;
     }
-    
+
     if (type == input) {
         alcCaptureStart(device->dhndl);
         thread_paused = false;
     }
-    
+
     unlock;
     return de_None;
 }
@@ -301,64 +325,63 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx
 DeviceError close_device(DeviceType type, uint32_t device_idx)
 {
     if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
-    
+
     lock;
-    Device* device = running[type][device_idx];
+    Device *device = running[type][device_idx];
     DeviceError rc = de_None;
-    
-    if (!device) { 
+
+    if (!device) {
         unlock;
         return de_DeviceNotActive;
     }
-    
+
     running[type][device_idx] = NULL;
-    
+
     if ( !device->ref_count ) {
-        
-//         printf("Closed device ");
-        
         if (type == input) {
             if ( !alcCaptureCloseDevice(device->dhndl) ) rc = de_AlError;
-        }
-        else { 
+        } else {
             if (alcGetCurrentContext() != device->ctx) alcMakeContextCurrent(device->ctx);
-            
+
             alDeleteSources(1, &device->source);
             alDeleteBuffers(OPENAL_BUFS, device->buffers);
-            
+
             alcMakeContextCurrent(NULL);
+
             if ( device->ctx ) alcDestroyContext(device->ctx);
+
             if ( !alcCloseDevice(device->dhndl) ) rc = de_AlError;
         }
-        
+
         free(device);
-    }
-    else device->ref_count--;
-    
+    } else device->ref_count--;
+
     unlock;
     return rc;
 }
 
-DeviceError register_device_callback( int32_t call_idx, uint32_t device_idx, DataHandleCallback callback, void* data, bool enable_VAD)
-{    
-    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL) 
+DeviceError register_device_callback( int32_t friend_number, uint32_t device_idx, DataHandleCallback callback,
+                                      void *data, bool enable_VAD)
+{
+    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
         return de_InvalidSelection;
 
     lock;
     running[input][device_idx]->cb = callback;
     running[input][device_idx]->cb_data = data;
     running[input][device_idx]->enable_VAD = enable_VAD;
-    running[input][device_idx]->call_idx = call_idx;
+    running[input][device_idx]->friend_number = friend_number;
     unlock;
 
     return de_None;
 }
 
-inline__ DeviceError write_out(uint32_t device_idx, const int16_t* data, uint32_t length, uint8_t channels)
+inline__ DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_t sample_count, uint8_t channels,
+                               uint32_t sample_rate)
 {
     if (device_idx >= MAX_DEVICES) return de_InvalidSelection;
 
-    Device* device = running[output][device_idx];
+    Device *device = running[output][device_idx];
 
     if (!device || device->muted) return de_DeviceNotActive;
 
@@ -370,33 +393,33 @@ inline__ DeviceError write_out(uint32_t device_idx, const int16_t* data, uint32_
     alGetSourcei(device->source, AL_BUFFERS_PROCESSED, &processed);
     alGetSourcei(device->source, AL_BUFFERS_QUEUED, &queued);
 
-    if(processed) {
+    if (processed) {
         ALuint bufids[processed];
         alSourceUnqueueBuffers(device->source, processed, bufids);
         alDeleteBuffers(processed - 1, bufids + 1);
         bufid = bufids[0];
-    } 
-    else if(queued < 16) alGenBuffers(1, &bufid);
-    else { 
+    } else if (queued < 16) alGenBuffers(1, &bufid);
+    else {
         pthread_mutex_unlock(device->mutex);
         return de_Busy;
     }
 
 
-    alBufferData(bufid, device->sound_mode, data, length * 2 * channels, device->sample_rate);
+    alBufferData(bufid, channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16, data, sample_count * 2 * channels,
+                 sample_rate);
     alSourceQueueBuffers(device->source, 1, &bufid);
 
     ALint state;
     alGetSourcei(device->source, AL_SOURCE_STATE, &state);
 
-    if(state != AL_PLAYING) alSourcePlay(device->source);
+    if (state != AL_PLAYING) alSourcePlay(device->source);
 
 
     pthread_mutex_unlock(device->mutex);
     return de_None;
 }
 
-void* thread_poll (void* arg) // TODO: maybe use thread for every input source
+void *thread_poll (void *arg) // TODO: maybe use thread for every input source
 {
     /*
      * NOTE: We only need to poll input devices for data.
@@ -404,53 +427,68 @@ void* thread_poll (void* arg) // TODO: maybe use thread for every input source
     (void)arg;
     uint32_t i;
     int32_t sample = 0;
-    
-    
-    while (thread_running)
-    {
-        if (thread_paused) usleep(10000); /* Wait for unpause. */
-        else
-        {
-            for (i = 0; i < size[input]; ++i) 
-            {
+
+
+    while (1) {
+        lock;
+
+        if (!thread_running) {
+            unlock;
+            break;
+        }
+
+        bool paused = thread_paused;
+        unlock;
+
+        /* Wait for unpause. */
+        if (paused) {
+            usleep(10000);
+        }
+
+        else {
+            for (i = 0; i < size[input]; ++i) {
                 lock;
-                if (running[input][i] != NULL) 
-                {
+
+                if (running[input][i] != NULL) {
                     alcGetIntegerv(running[input][i]->dhndl, ALC_CAPTURE_SAMPLES, sizeof(int32_t), &sample);
-                    
+
                     int f_size = (running[input][i]->sample_rate * running[input][i]->frame_duration / 1000);
-                    
-                    if (sample < f_size) { 
+
+                    if (sample < f_size) {
                         unlock;
                         continue;
                     }
-                    Device* device = running[input][i];
-                    
+
+                    Device *device = running[input][i];
+
                     int16_t frame[16000];
                     alcCaptureSamples(device->dhndl, frame, f_size);
-                    
-                    if (device->muted) { 
+
+                    if (device->muted) {
                         unlock;
                         continue;
                     }
-                    
+
                     if ( device->cb ) device->cb(frame, f_size, device->cb_data);
-                } 
+                }
+
                 unlock;
             }
+
             usleep(5000);
         }
     }
-    
+
     pthread_exit(NULL);
 }
 
-void print_devices(ToxWindow* self, DeviceType type)
+void print_devices(ToxWindow *self, DeviceType type)
 {
     int i;
 
-    for (i = 0; i < size[type]; ++i)
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%d: %s", i, devices_names[type][i]);
+    for (i = 0; i < size[type]; ++i) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, i == primary_device[type] ? 1 : 0, 0, "%d: %s", i, devices_names[type][i]);
+    }
 
     return;
 }
@@ -460,10 +498,10 @@ DeviceError selection_valid(DeviceType type, int32_t selection)
     return (size[type] <= selection || selection < 0) ? de_InvalidSelection : de_None;
 }
 
-void* get_device_callback_data(uint32_t device_idx)
+void *get_device_callback_data(uint32_t device_idx)
 {
-    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL) 
+    if (size[input] <= device_idx || !running[input][device_idx] || running[input][device_idx]->dhndl == NULL)
         return NULL;
-        
+
     return running[input][device_idx]->cb_data;
 }

src/audio_device.h

@@ -1,4 +1,4 @@
-/*  device.h
+/*  audio_device.h
  *
  *
  *  Copyright (C) 2014 Toxic All Rights Reserved.
@@ -22,12 +22,12 @@
 
 /*
  * You can have multiple sources (Input devices) but only one output device.
- * Pass buffers to output device via write(); 
+ * Pass buffers to output device via write();
  * Read from running input device(s) via select()/callback combo.
  */
 
-#ifndef DEVICE_H
-#define DEVICE_H
+#ifndef AUDIO_DEVICE_H
+#define AUDIO_DEVICE_H
 
 #define OPENAL_BUFS 5
 #define MAX_DEVICES 32
@@ -52,20 +52,22 @@ typedef enum DeviceError {
     de_AlError = -9,
 } DeviceError;
 
-typedef void (*DataHandleCallback) (const int16_t*, uint32_t size, void* data);
+typedef void (*DataHandleCallback) (const int16_t *, uint32_t size, void *data);
 
 
 #ifdef AUDIO
-DeviceError init_devices(ToxAv* av);
+DeviceError init_devices(ToxAV *av);
 #else
 DeviceError init_devices();
 #endif /* AUDIO */
 
+void get_devices_names();
 DeviceError terminate_devices();
 
 /* Callback handles ready data from INPUT device */
-DeviceError register_device_callback(int32_t call_idx, uint32_t device_idx, DataHandleCallback callback, void* data, bool enable_VAD);
-void* get_device_callback_data(uint32_t device_idx);
+DeviceError register_device_callback(int32_t friend_number, uint32_t device_idx, DataHandleCallback callback,
+                                     void *data, bool enable_VAD);
+void *get_device_callback_data(uint32_t device_idx);
 
 /* toggle device mute */
 DeviceError device_mute(DeviceType type, uint32_t device_idx);
@@ -75,17 +77,20 @@ DeviceError device_set_VAD_treshold(uint32_t device_idx, float value);
 #endif
 
 DeviceError set_primary_device(DeviceType type, int32_t selection);
-DeviceError open_primary_device(DeviceType type, uint32_t* device_idx, uint32_t sample_rate, uint32_t frame_duration, uint8_t channels);
+DeviceError open_primary_device(DeviceType type, uint32_t *device_idx, uint32_t sample_rate, uint32_t frame_duration,
+                                uint8_t channels);
 /* Start device */
-DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx, uint32_t sample_rate, uint32_t frame_duration, uint8_t channels);
+DeviceError open_device(DeviceType type, int32_t selection, uint32_t *device_idx, uint32_t sample_rate,
+                        uint32_t frame_duration, uint8_t channels);
 /* Stop device */
 DeviceError close_device(DeviceType type, uint32_t device_idx);
 
 /* Write data to device */
-DeviceError write_out(uint32_t device_idx, const int16_t* data, uint32_t length, uint8_t channels);
+DeviceError write_out(uint32_t device_idx, const int16_t *data, uint32_t length, uint8_t channels,
+                      uint32_t sample_rate);
 
-void print_devices(ToxWindow* self, DeviceType type);
+void print_devices(ToxWindow *self, DeviceType type);
 void get_primary_device_name(DeviceType type, char *buf, int size);
 
 DeviceError selection_valid(DeviceType type, int32_t selection);
-#endif /* DEVICE_H */
+#endif /* AUDIO_DEVICE_H */

src/autocomplete.c

@@ -25,10 +25,10 @@
 #include <limits.h>
 
 #ifdef __APPLE__
-    #include <sys/types.h>
-    #include <sys/dir.h>
+#include <sys/types.h>
+#include <sys/dir.h>
 #else
-    #include <dirent.h>
+#include <dirent.h>
 #endif /* ifdef __APPLE__ */
 
 #include "windows.h"
@@ -53,12 +53,14 @@ static void print_matches(ToxWindow *self, Tox *m, const void *list, int n_items
 }
 
 /* puts match in match buffer. if more than one match, add first n chars that are identical.
-   e.g. if matches contains: [foo, foobar, foe] we put fo in matches. */
-static void get_str_match(ToxWindow *self, char *match, char (*matches)[MAX_STR_SIZE], int n)
+ * e.g. if matches contains: [foo, foobar, foe] we put fo in match.
+ *
+ * Returns the length of the match.
+ */
+static size_t get_str_match(ToxWindow *self, char *match, size_t match_sz, char (*matches)[MAX_STR_SIZE], int n)
 {
     if (n == 1) {
-        strcpy(match, matches[0]);
-        return;
+        return snprintf(match, match_sz, "%s", matches[0]);
     }
 
     int i;
@@ -71,14 +73,14 @@ static void get_str_match(ToxWindow *self, char *match, char (*matches)[MAX_STR_
             char ch2 = matches[j][i];
 
             if (ch1 != ch2 || !ch1) {
-                strcpy(match, matches[0]);
+                snprintf(match, match_sz, "%s", matches[0]);
                 match[i] = '\0';
-                return;
+                return i;
             }
         }
     }
 
-    strcpy(match, matches[0]);
+    return snprintf(match, match_sz, "%s", matches[0]);
 }
 
 /* looks for all instances in list that begin with the last entered word in line according to pos,
@@ -93,7 +95,7 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
 {
     ChatContext *ctx = self->chatwin;
 
-    if (ctx->pos <= 0 || ctx->len <= 0 || ctx->len >= MAX_STR_SIZE || size > MAX_STR_SIZE)
+    if (ctx->pos <= 0 || ctx->len <= 0 || ctx->pos > ctx->len || ctx->len >= MAX_STR_SIZE || size > MAX_STR_SIZE)
         return -1;
 
     const char *L = (char *) list;
@@ -106,7 +108,11 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
 
     /* TODO: generalize this */
     bool dir_search =    !strncmp(ubuf, "/sendfile", strlen("/sendfile"))
-                      || !strncmp(ubuf, "/avatar", strlen("/avatar"));
+                         || !strncmp(ubuf, "/avatar", strlen("/avatar"));
+
+#ifdef PYTHON
+    dir_search = dir_search || !strncmp(ubuf, "/run", strlen("/run"));
+#endif
 
     /* isolate substring from space behind pos to pos */
     char tmp[MAX_STR_SIZE];
@@ -114,7 +120,7 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
     tmp[ctx->pos] = '\0';
 
     const char *s = dir_search ? strchr(tmp, '\"') : strrchr(tmp, ' ');
-    char *sub = malloc(strlen(ubuf) + 1);
+    char *sub = calloc(1, strlen(ubuf) + 1);
 
     if (sub == NULL)
         exit_toxic_err("failed in complete_line", FATALERR_MEMORY);
@@ -136,20 +142,20 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
         }
     }
 
-    if (string_is_empty(sub)) {
+    if (!sub[0]) {
         free(sub);
         return -1;
     }
 
     int s_len = strlen(sub);
-    const char *str;
     int n_matches = 0;
     char matches[n_items][MAX_STR_SIZE];
     int i = 0;
 
     /* put all list matches in matches array */
     for (i = 0; i < n_items; ++i) {
-        str = &L[i * size];
+        char str[MAX_CMDNAME_SIZE + 1];
+        snprintf(str, sizeof(str), "%s", &L[i * size]);
 
         if (strncasecmp(str, sub, s_len) == 0)
             strcpy(matches[n_matches++], str);
@@ -164,11 +170,15 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
         print_matches(self, NULL, matches, n_matches, MAX_STR_SIZE);
 
     char match[MAX_STR_SIZE];
-    get_str_match(self, match, matches, n_matches);
+    size_t match_len = get_str_match(self, match, sizeof(match), matches, n_matches);
+
+    if (match_len == 0) {
+        return 0;
+    }
 
     if (dir_search) {
         if (n_matches == 1)
-            endchrs = char_rfind(match, '.', strlen(match)) ? "\"" : "/";
+            endchrs = char_rfind(match, '.', match_len) ? "\"" : "/";
         else
             endchrs = "";
     } else if (n_matches > 1) {
@@ -177,24 +187,29 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
 
     /* put match in correct spot in buf and append endchars */
     int n_endchrs = strlen(endchrs);
-    int m_len = strlen(match);
     int strt = ctx->pos - s_len;
-    int diff = m_len - s_len + n_endchrs;
+    int diff = match_len - s_len + n_endchrs;
 
     if (ctx->len + diff >= MAX_STR_SIZE)
         return -1;
 
     char tmpend[MAX_STR_SIZE];
-    strcpy(tmpend, &ubuf[ctx->pos]);
+    snprintf(tmpend, sizeof(tmpend), "%s", &ubuf[ctx->pos]);
+
+    if (match_len + n_endchrs + strlen(tmpend) >= sizeof(ubuf)) {
+        return -1;
+    }
+
     strcpy(&ubuf[strt], match);
-    strcpy(&ubuf[strt + m_len], endchrs);
-    strcpy(&ubuf[strt + m_len + n_endchrs], tmpend);
+    strcpy(&ubuf[strt + match_len], endchrs);
+    strcpy(&ubuf[strt + match_len + n_endchrs], tmpend);
 
     /* convert to widechar and copy back to original buf */
     wchar_t newbuf[MAX_STR_SIZE];
 
-    if (mbs_to_wcs_buf(newbuf, ubuf, MAX_STR_SIZE) == -1)
+    if (mbs_to_wcs_buf(newbuf, ubuf, sizeof(newbuf) / sizeof(wchar_t)) == -1) {
         return -1;
+    }
 
     wcscpy(ctx->line, newbuf);
 
@@ -218,7 +233,7 @@ static void complt_home_dir(ToxWindow *self, char *path, int pathsize, const cha
 
     wchar_t wline[MAX_STR_SIZE];
 
-    if (mbs_to_wcs_buf(wline, newline, sizeof(wline)) == -1)
+    if (mbs_to_wcs_buf(wline, newline, sizeof(wline) / sizeof(wchar_t)) == -1)
         return;
 
     int newlen = wcslen(wline);
@@ -261,10 +276,10 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
     } else if (!si && b_path[0] != '/') {    /* look for matches in pwd */
         char tmp[MAX_STR_SIZE];
         snprintf(tmp, sizeof(tmp), ".%s", b_path);
-        strcpy(b_path, tmp);
+        snprintf(b_path, sizeof(b_path), "%s", tmp);
     }
 
-    strcpy(b_name, &b_path[si + 1]);
+    snprintf(b_name, sizeof(b_name), "%s", &b_path[si + 1]);
     b_path[si + 1] = '\0';
     int b_name_len = strlen(b_name);
     DIR *dp = opendir(b_path);
@@ -272,13 +287,13 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
     if (dp == NULL)
         return -1;
 
-    char dirnames[MAX_DIRS][NAME_MAX];
+    char dirnames[MAX_DIRS][NAME_MAX + 1];
     struct dirent *entry;
     int dircount = 0;
 
     while ((entry = readdir(dp)) && dircount < MAX_DIRS) {
         if (strncmp(entry->d_name, b_name, b_name_len) == 0
-                                && strcmp(".", entry->d_name) && strcmp("..", entry->d_name)) {
+                && strcmp(".", entry->d_name) && strcmp("..", entry->d_name)) {
             snprintf(dirnames[dircount], sizeof(dirnames[dircount]), "%s", entry->d_name);
             ++dircount;
         }

src/avatars.c

@@ -0,0 +1,207 @@
+/*  avatars.c
+ *
+ *
+ *  Copyright (C) 2015 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/>.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "misc_tools.h"
+#include "file_transfers.h"
+#include "friendlist.h"
+#include "avatars.h"
+
+extern FriendsList Friends;
+
+static struct Avatar {
+    char name[TOX_MAX_FILENAME_LENGTH + 1];
+    size_t name_len;
+    char path[PATH_MAX + 1];
+    size_t path_len;
+    off_t size;
+} Avatar;
+
+
+static void avatar_clear(void)
+{
+    memset(&Avatar, 0, sizeof(struct Avatar));
+}
+
+/* Sends avatar to friendnum.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int avatar_send(Tox *m, uint32_t friendnum)
+{
+    TOX_ERR_FILE_SEND err;
+    uint32_t filenum = tox_file_send(m, friendnum, TOX_FILE_KIND_AVATAR, (size_t) Avatar.size,
+                                     NULL, (uint8_t *) Avatar.name, Avatar.name_len, &err);
+
+    if (Avatar.size == 0)
+        return 0;
+
+    if (err != TOX_ERR_FILE_SEND_OK) {
+        fprintf(stderr, "tox_file_send failed for friendnumber %d (error %d)\n", friendnum, err);
+        return -1;
+    }
+
+    struct FileTransfer *ft = new_file_transfer(NULL, friendnum, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_AVATAR);
+
+    if (!ft)
+        return -1;
+
+    ft->file = fopen(Avatar.path, "r");
+
+    if (ft->file == NULL)
+        return -1;
+
+    snprintf(ft->file_name, sizeof(ft->file_name), "%s", Avatar.name);
+    ft->file_size = Avatar.size;
+
+    return 0;
+}
+
+/* Sends avatar to all friends */
+static void avatar_send_all(Tox *m)
+{
+    size_t i;
+
+    for (i = 0; i < Friends.max_idx; ++i) {
+        if (Friends.list[i].connection_status != TOX_CONNECTION_NONE)
+            avatar_send(m, Friends.list[i].num);
+    }
+}
+
+/* Sets avatar to path and sends it to all online contacts.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int avatar_set(Tox *m, const char *path, size_t path_len)
+{
+    if (path_len == 0 || path_len >= sizeof(Avatar.path))
+        return -1;
+
+    FILE *fp = fopen(path, "rb");
+
+    if (fp == NULL)
+        return -1;
+
+    char PNG_signature[8] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};
+
+    if (check_file_signature(PNG_signature, sizeof(PNG_signature), fp) != 0) {
+        fclose(fp);
+        return -1;
+    }
+
+    fclose(fp);
+
+    off_t size = file_size(path);
+
+    if (size == 0 || size > MAX_AVATAR_FILE_SIZE)
+        return -1;
+
+    get_file_name(Avatar.name, sizeof(Avatar.name), path);
+    Avatar.name_len = strlen(Avatar.name);
+    snprintf(Avatar.path, sizeof(Avatar.path), "%s", path);
+    Avatar.path_len = path_len;
+    Avatar.size = size;
+
+    avatar_send_all(m);
+
+    return 0;
+}
+
+/* Unsets avatar and sends to all online contacts.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+void avatar_unset(Tox *m)
+{
+    avatar_clear();
+    avatar_send_all(m);
+}
+
+void on_avatar_file_control(Tox *m, struct FileTransfer *ft, TOX_FILE_CONTROL control)
+{
+    switch (control) {
+        case TOX_FILE_CONTROL_RESUME:
+            if (ft->state == FILE_TRANSFER_PENDING) {
+                ft->state = FILE_TRANSFER_STARTED;
+            } else if (ft->state == FILE_TRANSFER_PAUSED) {
+                ft->state = FILE_TRANSFER_STARTED;
+            }
+
+            break;
+
+        case TOX_FILE_CONTROL_PAUSE:
+            ft->state = FILE_TRANSFER_PAUSED;
+            break;
+
+        case TOX_FILE_CONTROL_CANCEL:
+            close_file_transfer(NULL, m, ft, -1, NULL, silent);
+            break;
+    }
+}
+
+void on_avatar_chunk_request(Tox *m, struct FileTransfer *ft, uint64_t position, size_t length)
+{
+    if (ft->state != FILE_TRANSFER_STARTED)
+        return;
+
+    if (length == 0) {
+        close_file_transfer(NULL, m, ft, -1, NULL, silent);
+        return;
+    }
+
+    if (ft->file == NULL) {
+        close_file_transfer(NULL, m, ft, TOX_FILE_CONTROL_CANCEL, NULL, silent);
+        return;
+    }
+
+    if (ft->position != position) {
+        if (fseek(ft->file, position, SEEK_SET) == -1) {
+            close_file_transfer(NULL, m, ft, TOX_FILE_CONTROL_CANCEL, NULL, silent);
+            return;
+        }
+
+        ft->position = position;
+    }
+
+    uint8_t send_data[length];
+    size_t send_length = fread(send_data, 1, sizeof(send_data), ft->file);
+
+    if (send_length != length) {
+        close_file_transfer(NULL, m, ft, TOX_FILE_CONTROL_CANCEL, NULL, silent);
+        return;
+    }
+
+    TOX_ERR_FILE_SEND_CHUNK err;
+    tox_file_send_chunk(m, ft->friendnum, ft->filenum, position, send_data, send_length, &err);
+
+    if (err != TOX_ERR_FILE_SEND_CHUNK_OK)
+        fprintf(stderr, "tox_file_send_chunk failed in avatar callback (error %d)\n", err);
+
+    ft->position += send_length;
+    ft->last_keep_alive = get_unix_time();
+}

src/avatars.h

@@ -0,0 +1,52 @@
+/*  avatars.h
+ *
+ *
+ *  Copyright (C) 2015 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 AVATARS_H
+#define AVATARS_H
+
+#define MAX_AVATAR_FILE_SIZE 65536
+
+/* Sends avatar to friendnum.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int avatar_send(Tox *m, uint32_t friendnum);
+
+/* Sets avatar to path and sends it to all online contacts.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int avatar_set(Tox *m, const char *path, size_t length);
+
+/* Unsets avatar and sends to all online contacts.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+void avatar_unset(Tox *m);
+
+void on_avatar_chunk_request(Tox *m, struct FileTransfer *ft, uint64_t position, size_t length);
+void on_avatar_file_control(Tox *m, struct FileTransfer *ft, TOX_FILE_CONTROL control);
+
+#endif /* AVATARS_H */

src/bootstrap.c

@@ -0,0 +1,586 @@
+/*  bootstrap.c
+ *
+ *
+ *  Copyright (C) 2016 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/>.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <limits.h>
+
+#include <curl/curl.h>
+#include <tox/tox.h>
+
+#include "line_info.h"
+#include "windows.h"
+#include "misc_tools.h"
+#include "configdir.h"
+#include "curl_util.h"
+#include "settings.h"
+
+extern struct arg_opts arg_opts;
+extern struct user_settings *user_settings;
+extern struct Winthread Winthread;
+
+/* URL that we get the JSON encoded nodes list from. */
+#define NODES_LIST_URL "https://nodes.tox.chat/json"
+
+#define DEFAULT_NODES_FILENAME "DHTnodes.json"
+
+/* Time to wait between bootstrap attempts */
+#define TRY_BOOTSTRAP_INTERVAL 5
+
+/* Number of nodes to bootstrap to per try */
+#define NUM_BOOTSTRAP_NODES 5
+
+/* Number of seconds since last successful ping before we consider a node offline */
+#define NODE_OFFLINE_TIMOUT (60*60*24*2)
+
+#define IP_MAX_SIZE 45
+#define IP_MIN_SIZE 7
+#define PORT_MAX_SIZE 5
+
+#define LAST_SCAN_JSON_KEY "\"last_scan\":"
+#define LAST_SCAN_JSON_KEY_LEN (sizeof(LAST_SCAN_JSON_KEY) - 1)
+
+#define IPV4_JSON_KEY "\"ipv4\":\""
+#define IPV4_JSON_KEY_LEN (sizeof(IPV4_JSON_KEY) - 1)
+
+#define IPV6_JSON_KEY "\"ipv6\":\""
+#define IPV6_JSON_KEY_LEN (sizeof(IPV6_JSON_KEY) - 1)
+
+#define PORT_JSON_KEY "\"port\":"
+#define PORT_JSON_KEY_LEN (sizeof(PORT_JSON_KEY) - 1)
+
+#define PK_JSON_KEY "\"public_key\":\""
+#define PK_JSON_KEY_LEN (sizeof(PK_JSON_KEY) - 1)
+
+#define LAST_PING_JSON_KEY "\"last_ping\":"
+#define LAST_PING_JSON_KEY_LEN (sizeof(LAST_PING_JSON_KEY) - 1)
+
+/* Maximum allowable size of the nodes list */
+#define MAX_NODELIST_SIZE (MAX_RECV_CURL_DATA_SIZE)
+
+
+static struct Thread_Data {
+    pthread_t tid;
+    pthread_attr_t attr;
+    pthread_mutex_t lock;
+    volatile bool active;
+} thread_data;
+
+#define MAX_NODES 50
+struct Node {
+    char ip4[IP_MAX_SIZE + 1];
+    bool have_ip4;
+
+    char ip6[IP_MAX_SIZE + 1];
+    bool have_ip6;
+
+    char key[TOX_PUBLIC_KEY_SIZE];
+    uint16_t port;
+};
+
+static struct DHT_Nodes {
+    struct Node list[MAX_NODES];
+    size_t count;
+    time_t last_updated;
+} Nodes;
+
+
+/* Determine if a node is offline by comparing the age of the nodeslist
+ * to the last time the node was successfully pinged.
+ */
+#define NODE_IS_OFFLINE(last_scan, last_ping) ((last_ping + NODE_OFFLINE_TIMOUT) <= (last_ping))
+
+/* Return true if nodeslist pointed to by fp needs to be updated.
+ * This will be the case if the file is empty, has an invalid format,
+ * or if the file is older than the given timeout.
+ */
+static bool nodeslist_needs_update(const char *nodes_path)
+{
+    if (user_settings->nodeslist_update_freq <= 0) {
+        return false;
+    }
+
+    FILE *fp = fopen(nodes_path, "r+");
+
+    if (fp == NULL) {
+        return false;
+    }
+
+    /* last_scan value should be at beginning of file */
+    char line[LAST_SCAN_JSON_KEY_LEN + 32];
+
+    if (fgets(line, sizeof(line), fp) == NULL) {
+        fclose(fp);
+        return true;
+    }
+
+    fclose(fp);
+
+    const char *last_scan_val = strstr(line, LAST_SCAN_JSON_KEY);
+
+    if (last_scan_val == NULL) {
+        return true;
+    }
+
+    long long int last_scan = strtoll(last_scan_val + LAST_SCAN_JSON_KEY_LEN, NULL, 10);
+
+    pthread_mutex_lock(&thread_data.lock);
+    Nodes.last_updated = last_scan;
+    pthread_mutex_unlock(&thread_data.lock);
+
+    pthread_mutex_lock(&Winthread.lock);
+    bool is_timeout = timed_out(last_scan, user_settings->nodeslist_update_freq * 24 * 60 * 60);
+    pthread_mutex_unlock(&Winthread.lock);
+
+    if (is_timeout) {
+        return true;
+    }
+
+    return false;
+}
+
+/* Fetches the JSON encoded DHT nodeslist from NODES_LIST_URL.
+ *
+ * Return 0 on success.
+ * Return -1 on failure.
+ */
+static int curl_fetch_nodes_JSON(struct Recv_Curl_Data *recv_data)
+{
+    CURL *c_handle = curl_easy_init();
+
+    if (c_handle == NULL) {
+        return -1;
+    }
+
+    int err = -1;
+
+    struct curl_slist *headers = NULL;
+    headers = curl_slist_append(headers, "Content-Type: application/json");
+    headers = curl_slist_append(headers, "charsets: utf-8");
+
+    curl_easy_setopt(c_handle, CURLOPT_HTTPHEADER, headers);
+    curl_easy_setopt(c_handle, CURLOPT_URL, NODES_LIST_URL);
+    curl_easy_setopt(c_handle, CURLOPT_WRITEFUNCTION, curl_cb_write_data);
+    curl_easy_setopt(c_handle, CURLOPT_WRITEDATA, recv_data);
+    curl_easy_setopt(c_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
+    curl_easy_setopt(c_handle, CURLOPT_HTTPGET, 1L);
+
+    int proxy_ret = set_curl_proxy(c_handle, arg_opts.proxy_address, arg_opts.proxy_port, arg_opts.proxy_type);
+
+    if (proxy_ret != 0) {
+        fprintf(stderr, "set_curl_proxy() failed with error %d\n", proxy_ret);
+        goto on_exit;
+    }
+
+    int ret = curl_easy_setopt(c_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
+
+    if (ret != CURLE_OK) {
+        fprintf(stderr, "TLSv1.2 could not be set (libcurl error %d)", ret);
+        goto on_exit;
+    }
+
+    ret = curl_easy_setopt(c_handle, CURLOPT_SSL_CIPHER_LIST, TLS_CIPHER_SUITE_LIST);
+
+    if (ret != CURLE_OK) {
+        fprintf(stderr, "Failed to set TLS cipher list (libcurl error %d)", ret);
+        goto on_exit;
+    }
+
+    ret = curl_easy_perform(c_handle);
+
+    if (ret != CURLE_OK) {
+        /* If system doesn't support any of the specified ciphers suites, fall back to default */
+        if (ret == CURLE_SSL_CIPHER) {
+            curl_easy_setopt(c_handle, CURLOPT_SSL_CIPHER_LIST, NULL);
+            ret = curl_easy_perform(c_handle);
+        }
+
+        if (ret != CURLE_OK) {
+            fprintf(stderr, "HTTPS lookup error (libcurl error %d)\n", ret);
+            goto on_exit;
+        }
+    }
+
+    err = 0;
+
+on_exit:
+    curl_slist_free_all(headers);
+    curl_easy_cleanup(c_handle);
+    return err;
+}
+
+/* Attempts to update the DHT nodeslist.
+ *
+ * Return 1 if list was updated successfully.
+ * Return 0 if list does not need to be updated.
+ * Return -1 if file cannot be opened.
+ * Return -2 if http lookup failed.
+ * Return -3 if http reponse was empty.
+ * Return -4 if data could not be written to disk.
+ */
+static int update_DHT_nodeslist(const char *nodes_path)
+{
+    if (!nodeslist_needs_update(nodes_path)) {
+        return 0;
+    }
+
+    FILE *fp = fopen(nodes_path, "r+");
+
+    if (fp == NULL) {
+        return -1;
+    }
+
+    struct Recv_Curl_Data recv_data;
+
+    memset(&recv_data, 0, sizeof(struct Recv_Curl_Data));
+
+    if (curl_fetch_nodes_JSON(&recv_data) == -1) {
+        fclose(fp);
+        return -2;
+    }
+
+    if (recv_data.length == 0) {
+        fclose(fp);
+        return -3;
+    }
+
+    if (fwrite(recv_data.data, recv_data.length, 1, fp) != 1) {
+        fclose(fp);
+        return -4;
+    }
+
+    fclose(fp);
+    return 1;
+}
+
+static void get_nodeslist_path(char *buf, size_t buf_size)
+{
+    char *config_dir = NULL;
+
+    if (arg_opts.nodes_path[0]) {
+        snprintf(buf, buf_size, "%s", arg_opts.nodes_path);
+    } else if ((config_dir = get_user_config_dir()) != NULL) {
+        snprintf(buf, buf_size, "%s%s%s", config_dir, CONFIGDIR, DEFAULT_NODES_FILENAME);
+        free(config_dir);
+    } else {
+        snprintf(buf, buf_size, "%s", DEFAULT_NODES_FILENAME);
+    }
+}
+
+/* Return true if json encoded string s contains a valid IP address and puts address in ip_buf.
+ *
+ * ip_type should be set to 1 for ipv4 address, or 0 for ipv6 addresses.
+ * ip_buf must have room for at least IP_MAX_SIZE + 1 bytes.
+ */
+static bool extract_val_ip(const char *s, char *ip_buf, unsigned short int ip_type)
+{
+    int ip_len = char_find(0, s, '"');
+
+    if (ip_len < IP_MIN_SIZE || ip_len > IP_MAX_SIZE) {
+        return false;
+    }
+
+    memcpy(ip_buf, s, ip_len);
+    ip_buf[ip_len] = 0;
+
+    return (ip_type == 1) ? is_ip4_address(ip_buf) : is_ip6_address(ip_buf);
+}
+
+/* Extracts the port from json encoded string s.
+ *
+ * Return port number on success.
+ * Return 0 on failure.
+ */
+static uint16_t extract_val_port(const char *s)
+{
+    long int port = strtol(s, NULL, 10);
+    return (port > 0 && port <= MAX_PORT_RANGE) ? port : 0;
+}
+
+/* Extracts the last pinged value from json encoded string s.
+ *
+ * Return timestamp on success.
+ * Return -1 on failure.
+ */
+static long long int extract_val_last_pinged(const char *s)
+{
+    long long int last_pinged = strtoll(s, NULL, 10);
+    return (last_pinged <= 0) ? -1 : last_pinged;
+}
+
+/* Extracts DHT public key from json encoded string s and puts key in key_buf.
+ * key_buf must have room for at least TOX_PUBLIC_KEY_SIZE * 2 + 1 bytes.
+ *
+ * Return number of bytes copied to key_buf on success.
+ * Return -1 on failure.
+ */
+static int extract_val_pk(const char *s, char *key_buf)
+{
+
+    int key_len = char_find(0, s, '"');
+
+    if (key_len != TOX_PUBLIC_KEY_SIZE * 2) {
+        return -1;
+    }
+
+    memcpy(key_buf, s, key_len);
+    key_buf[key_len] = 0;
+
+    return key_len;
+}
+
+/* Extracts values from json formatted string, validats them, and puts them in node.
+ *
+ * Return 0 on success.
+ * Return -1 if line is empty.
+ * Return -2 if line does not appear to be a valid nodes list entry.
+ * Return -3 if node appears to be offline.
+ * Return -4 if entry does not contain either a valid ipv4 or ipv6 address.
+ * Return -5 if port value is invalid.
+ * Return -6 if public key is invalid.
+ */
+static int extract_node(const char *line, struct Node *node)
+{
+    if (!line) {
+        return -1;
+    }
+
+    const char *ip4_start = strstr(line, IPV4_JSON_KEY);
+    const char *ip6_start = strstr(line, IPV6_JSON_KEY);
+    const char *port_start = strstr(line, PORT_JSON_KEY);
+    const char *key_start = strstr(line, PK_JSON_KEY);
+    const char *last_pinged_str = strstr(line, LAST_PING_JSON_KEY);
+
+    if (!ip4_start || !ip6_start || !port_start || !key_start || !last_pinged_str) {
+        return -2;
+    }
+
+    long long int last_pinged = extract_val_last_pinged(last_pinged_str + LAST_PING_JSON_KEY_LEN);
+
+    if (last_pinged <= 0 || NODE_IS_OFFLINE(Nodes.last_scan, last_pinged)) {
+        return -3;
+    }
+
+    char ip4_string[IP_MAX_SIZE + 1];
+    bool have_ip4 = extract_val_ip(ip4_start + IPV4_JSON_KEY_LEN, ip4_string, 1);
+
+    char ip6_string[IP_MAX_SIZE + 1];
+    bool have_ip6 = extract_val_ip(ip6_start + IPV6_JSON_KEY_LEN, ip6_string, 0);
+
+    if (!have_ip6 && !have_ip4) {
+        return -4;
+    }
+
+    uint16_t port = extract_val_port(port_start + PORT_JSON_KEY_LEN);
+
+    if (port == 0) {
+        return -5;
+    }
+
+    char key_string[TOX_PUBLIC_KEY_SIZE * 2 + 1];
+    int key_len = extract_val_pk(key_start + PK_JSON_KEY_LEN, key_string);
+
+    if (key_len == -1) {
+        return -6;
+    }
+
+    if (hex_string_to_bin(key_string, key_len, node->key, TOX_PUBLIC_KEY_SIZE) == -1) {
+        return -6;
+    }
+
+    if (have_ip4) {
+        snprintf(node->ip4, sizeof(node->ip4), "%s", ip4_string);
+        node->have_ip4 = true;
+    }
+
+    if (have_ip6) {
+        snprintf(node->ip6, sizeof(node->ip6), "%s", ip6_string);
+        node->have_ip6 = true;
+    }
+
+    node->port = port;
+
+    return 0;
+}
+
+/* Loads the DHT nodeslist to memory from json encoded nodes file. */
+void *load_nodeslist_thread(void *data)
+{
+    char nodes_path[PATH_MAX];
+    get_nodeslist_path(nodes_path, sizeof(nodes_path));
+
+    FILE *fp = NULL;
+
+    if (!file_exists(nodes_path)) {
+        if ((fp = fopen(nodes_path, "w+")) == NULL) {
+            fprintf(stderr, "nodeslist load error: failed to create file '%s'\n", nodes_path);
+            goto on_exit;
+        }
+    } else if ((fp = fopen(nodes_path, "r+")) == NULL) {
+        fprintf(stderr, "nodeslist load error: failed to open file '%s'\n", nodes_path);
+        goto on_exit;
+    }
+
+    int update_err = update_DHT_nodeslist(nodes_path);
+
+    if (update_err < 0) {
+        fprintf(stderr, "update_DHT_nodeslist() failed with error %d\n", update_err);
+    }
+
+    char line[MAX_NODELIST_SIZE + 1];
+
+    if (fgets(line, sizeof(line), fp) == NULL) {
+        fclose(fp);
+        fprintf(stderr, "nodeslist load error: file empty.\n");
+        goto on_exit;
+    }
+
+    size_t idx = 0;
+    const char *line_start = line;
+
+    while ((line_start = strstr(line_start + 1, IPV4_JSON_KEY))) {
+        pthread_mutex_lock(&thread_data.lock);
+        idx = Nodes.count;
+
+        if (idx >= MAX_NODES) {
+            pthread_mutex_unlock(&thread_data.lock);
+            break;
+        }
+
+        if (extract_node(line_start, &Nodes.list[idx]) == 0) {
+            ++Nodes.count;
+        }
+
+        pthread_mutex_unlock(&thread_data.lock);
+    }
+
+    /* If nodeslist does not contain any valid entries we set the last_scan value
+     * to 0 so that it will fetch a new list the next time this function is called.
+     */
+    if (Nodes.count == 0) {
+        const char *s = "{\"last_scan\":0}";
+        rewind(fp);
+        fwrite(s, strlen(s), 1, fp);  // Not much we can do if it fails
+        fclose(fp);
+        fprintf(stderr, "nodeslist load error: List did not contain any valid entries.\n");
+        goto on_exit;
+    }
+
+    fclose(fp);
+
+on_exit:
+    thread_data.active = false;
+    pthread_attr_destroy(&thread_data.attr);
+    pthread_exit(0);
+}
+
+/* Creates a new thread that will load the DHT nodeslist to memory
+ * from json encoded nodes file obtained at NODES_LIST_URL. Only one
+ * thread may run at a time.
+ *
+ * Return 0 on success.
+ * Return -1 if a thread is already active.
+ * Return -2 if mutex fails to init.
+ * Return -3 if pthread attribute fails to init.
+ * Return -4 if pthread fails to set detached state.
+ * Return -5 if thread creation fails.
+ */
+int load_DHT_nodeslist(void)
+{
+    if (thread_data.active) {
+        return -1;
+    }
+
+    if (pthread_mutex_init(&thread_data.lock, NULL) != 0) {
+        return -2;
+    }
+
+    if (pthread_attr_init(&thread_data.attr) != 0) {
+        return -3;
+    }
+
+    if (pthread_attr_setdetachstate(&thread_data.attr, PTHREAD_CREATE_DETACHED) != 0) {
+        return -4;
+    }
+
+    thread_data.active = true;
+
+    if (pthread_create(&thread_data.tid, &thread_data.attr, load_nodeslist_thread, NULL) != 0) {
+        thread_data.active = false;
+        return -5;
+    }
+
+    return 0;
+}
+
+/* Connects to NUM_BOOTSTRAP_NODES random DHT nodes listed in the DHTnodes file. */
+static void DHT_bootstrap(Tox *m)
+{
+    pthread_mutex_lock(&thread_data.lock);
+    size_t num_nodes = Nodes.count;
+    pthread_mutex_unlock(&thread_data.lock);
+
+    if (num_nodes == 0) {
+        return;
+    }
+
+    size_t i;
+
+    pthread_mutex_lock(&thread_data.lock);
+
+    for (i = 0; i < NUM_BOOTSTRAP_NODES; ++i) {
+        struct Node *node = &Nodes.list[rand() % Nodes.count];
+        const char *addr = node->have_ip4 ? node->ip4 : node->ip6;
+
+        if (!addr) {
+            continue;
+        }
+
+        TOX_ERR_BOOTSTRAP err;
+        tox_bootstrap(m, addr, node->port, (uint8_t *) node->key, &err);
+
+        if (err != TOX_ERR_BOOTSTRAP_OK) {
+            fprintf(stderr, "Failed to bootstrap %s:%d\n", addr, node->port);
+        }
+
+        tox_add_tcp_relay(m, addr, node->port, (uint8_t *) node->key, &err);
+
+        if (err != TOX_ERR_BOOTSTRAP_OK) {
+            fprintf(stderr, "Failed to add TCP relay %s:%d\n", addr, node->port);
+        }
+    }
+
+    pthread_mutex_unlock(&thread_data.lock);
+}
+
+/* Manages connection to the Tox DHT network. */
+void do_tox_connection(Tox *m)
+{
+    static time_t last_bootstrap_time = 0;
+    bool connected = tox_self_get_connection_status(m) != TOX_CONNECTION_NONE;
+
+    if (!connected && timed_out(last_bootstrap_time, TRY_BOOTSTRAP_INTERVAL)) {
+        DHT_bootstrap(m);
+        last_bootstrap_time = get_unix_time();
+    }
+}

src/bootstrap.h

@@ -0,0 +1,42 @@
+/*  bootstrap.h
+ *
+ *
+ *  Copyright (C) 2016 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 BOOTSTRAP_H
+#define BOOTSTRAP_H
+
+/* Manages connection to the Tox DHT network. */
+void do_tox_connection(Tox *m);
+
+/* Creates a new thread that will load the DHT nodeslist to memory
+ * from json encoded nodes file obtained at NODES_LIST_URL. Only one
+ * thread may run at a time.
+ *
+ * Return 0 on success.
+ * Return -1 if a thread is already active.
+ * Return -2 if mutex fails to init.
+ * Return -3 if pthread attribute fails to init.
+ * Return -4 if pthread fails to set detached state.
+ * Return -5 if thread creation fails.
+ */
+int load_DHT_nodeslist(void);
+
+#endif  /* BOOTSTRAP_H */

src/chat.c

@@ -48,8 +48,11 @@
 #include "message_queue.h"
 
 #ifdef AUDIO
-    #include "audio_call.h"
-#endif /* AUDIO */
+#include "audio_call.h"
+#ifdef VIDEO
+#include "video_call.h"
+#endif  /* VIDEO */
+#endif  /* AUDIO */
 
 extern char *DATA_FILE;
 extern FriendsList Friends;
@@ -62,10 +65,14 @@ static void init_infobox(ToxWindow *self);
 static void kill_infobox(ToxWindow *self);
 #endif  /* AUDIO */
 
-#ifdef AUDIO
-#define AC_NUM_CHAT_COMMANDS 27
+#if defined(AUDIO) && defined(PYTHON)
+#define AC_NUM_CHAT_COMMANDS 32
+#elif AUDIO
+#define AC_NUM_CHAT_COMMANDS 31
+#elif PYTHON
+#define AC_NUM_CHAT_COMMANDS 23
 #else
-#define AC_NUM_CHAT_COMMANDS 20
+#define AC_NUM_CHAT_COMMANDS 22
 #endif /* AUDIO */
 
 /* Array of chat command names used for tab completion. */
@@ -84,8 +91,10 @@ static const char chat_cmd_list[AC_NUM_CHAT_COMMANDS][MAX_CMDNAME_SIZE] = {
     { "/join"       },
     { "/log"        },
     { "/myid"       },
+    { "/myqr"       },
     { "/nick"       },
     { "/note"       },
+    { "/nospam"     },
     { "/quit"       },
     { "/savefile"   },
     { "/sendfile"   },
@@ -100,8 +109,16 @@ static const char chat_cmd_list[AC_NUM_CHAT_COMMANDS][MAX_CMDNAME_SIZE] = {
     { "/sdev"       },
     { "/mute"       },
     { "/sense"      },
+    { "/video"      },
+    { "/bitrate"    },
 
 #endif /* AUDIO */
+
+#ifdef PYTHON
+
+    { "/run"        },
+
+#endif /* PYTHON */
 };
 
 static void set_self_typingstatus(ToxWindow *self, Tox *m, bool is_typing)
@@ -120,15 +137,18 @@ void kill_chat_window(ToxWindow *self, Tox *m)
     ChatContext *ctx = self->chatwin;
     StatusBar *statusbar = self->stb;
 
+#ifdef AUDIO
+#ifdef VIDEO
+    stop_video_stream(self);
+#endif  /* VIDEO */
+    stop_current_call(self);
+#endif  /* AUDIO */
+
     kill_all_file_transfers_friend(m, self->num);
     log_disable(ctx->log);
     line_info_cleanup(ctx->hst);
     cqueue_cleanup(ctx->cqueue);
 
-#ifdef AUDIO
-    stop_current_call(self);
-#endif
-
     delwin(ctx->linewin);
     delwin(ctx->history);
     delwin(statusbar->topline);
@@ -143,7 +163,7 @@ void kill_chat_window(ToxWindow *self, Tox *m)
 }
 
 static void recv_message_helper(ToxWindow *self, Tox *m, uint32_t num, const char *msg, size_t len,
-                               const char *nick, const char *timefrmt)
+                                const char *nick, const char *timefrmt)
 {
     ChatContext *ctx = self->chatwin;
 
@@ -151,9 +171,11 @@ static void recv_message_helper(ToxWindow *self, Tox *m, uint32_t num, const cha
     write_to_log(msg, nick, ctx->log, false);
 
     if (self->active_box != -1)
-        box_notify2(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS, self->active_box, "%s", msg);
+        box_notify2(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
+                    self->active_box, "%s", msg);
     else
-        box_notify(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS, &self->active_box, nick, "%s", msg);
+        box_notify(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
+                   &self->active_box, nick, "%s", msg);
 }
 
 static void recv_action_helper(ToxWindow *self, Tox *m, uint32_t num, const char *action, size_t len,
@@ -165,9 +187,11 @@ static void recv_action_helper(ToxWindow *self, Tox *m, uint32_t num, const char
     write_to_log(action, nick, ctx->log, true);
 
     if (self->active_box != -1)
-        box_notify2(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS, self->active_box, "* %s %s", nick, action );
+        box_notify2(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
+                    self->active_box, "* %s %s", nick, action );
     else
-        box_notify(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS, &self->active_box, self->name, "* %s %s", nick, action );
+        box_notify(self, generic_message, NT_WNDALERT_1 | NT_NOFOCUS | user_settings->bell_on_message,
+                   &self->active_box, self->name, "* %s %s", nick, action );
 }
 
 static void chat_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TYPE type, const char *msg, size_t len)
@@ -188,8 +212,8 @@ static void chat_onMessage(ToxWindow *self, Tox *m, uint32_t num, TOX_MESSAGE_TY
         return recv_action_helper(self, m, num, msg, len, nick, timefrmt);
 }
 
-static void chat_resume_file_transfers(Tox *m, uint32_t fnum);
-static void chat_stop_file_senders(uint32_t friendnum);
+static void chat_pause_file_transfers(Tox *m, uint32_t friendnum);
+static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t fnum);
 
 static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_CONNECTION connection_status)
 {
@@ -206,23 +230,28 @@ static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_C
     char nick[TOX_MAX_NAME_LENGTH];
     get_nick_truncate(m, nick, num);
 
+    TOX_CONNECTION prev_status = statusbar->connection;
     statusbar->connection = connection_status;
 
-    if (connection_status != TOX_CONNECTION_NONE) {
+    if (user_settings->show_connection_msg == SHOW_WELCOME_MSG_OFF) {
+        return;
+    }
+
+    if (prev_status == TOX_CONNECTION_NONE) {
         Friends.list[num].is_typing = user_settings->show_typing_other == SHOW_TYPING_ON
                                       ? tox_friend_get_typing(m, num, NULL) : false;
-        chat_resume_file_transfers(m, num);
+        chat_resume_file_senders(self, m, num);
 
         msg = "has come online";
         line_info_add(self, timefrmt, nick, NULL, CONNECTION, 0, GREEN, msg);
         write_to_log(msg, nick, ctx->log, true);
-    } else {
+    } else if (connection_status == TOX_CONNECTION_NONE) {
         Friends.list[num].is_typing = false;
 
         if (self->chatwin->self_is_typing)
             set_self_typingstatus(self, m, 0);
 
-        chat_stop_file_senders(num);
+        chat_pause_file_transfers(m, num);
 
         msg = "has gone offline";
         line_info_add(self, timefrmt, nick, NULL, DISCONNECTION, 0, RED, msg);
@@ -277,198 +306,262 @@ static void chat_onReadReceipt(ToxWindow *self, Tox *m, uint32_t num, uint32_t r
     cqueue_remove(self, m, receipt);
 }
 
-/* Stops active file senders for this friend. Call when a friend goes offline */
-static void chat_stop_file_senders(uint32_t friendnum)
+/* Stops active file transfers for this friend. Called when a friend goes offline */
+static void chat_pause_file_transfers(Tox *m, uint32_t friendnum)
 {
-    // size_t i;
+    ToxicFriend *friend = &Friends.list[friendnum];
 
-    // for (i = 0; i < MAX_FILES; ++i) {
-    //     if (Friends.list[friendnum].file_sender[i].active)
-    //         Friends.list[friendnum].file_sender[i].noconnection = true;
-    // }
+    size_t i;
+
+    for (i = 0; i < MAX_FILES; ++i) {
+        if (friend->file_sender[i].state >= FILE_TRANSFER_STARTED)
+            friend->file_sender[i].state = FILE_TRANSFER_PAUSED;
+
+        if (friend->file_receiver[i].state >= FILE_TRANSFER_STARTED)
+            friend->file_receiver[i].state = FILE_TRANSFER_PAUSED;
+    }
 }
 
-/* Tries to resume broken file transfers. Call when a friend comes online */
-static void chat_resume_file_transfers(Tox *m, uint32_t fnum)
+/* Tries to resume broken file senders. Called when a friend comes online */
+static void chat_resume_file_senders(ToxWindow *self, Tox *m, uint32_t friendnum)
 {
-    // size_t i;
+    size_t i;
 
-    // for (i = 0; i < MAX_FILES; ++i) {
-    //     if (Friends.list[fnum].file_receiver[i].active) {
-    //         uint8_t bytes_recv[sizeof(uint64_t)];
-    //         memcpy(bytes_recv, &Friends.list[fnum].file_receiver[i].bytes_recv, sizeof(uint64_t));
-    //         net_to_host(bytes_recv, sizeof(uint64_t));
-    //         uint32_t filenum = Friends.list[fnum].file_receiver[i].filenum;
-    //         tox_file_send_control(m, fnum, 1, filenum, TOX_FILECONTROL_RESUME_BROKEN, bytes_recv, sizeof(uint64_t));
-    //     }
-    // }
+    for (i = 0; i < MAX_FILES; ++i) {
+        struct FileTransfer *ft = &Friends.list[friendnum].file_sender[i];
+
+        if (ft->state != FILE_TRANSFER_PAUSED)
+            continue;
+
+        TOX_ERR_FILE_SEND err;
+        ft->filenum = tox_file_send(m, friendnum, TOX_FILE_KIND_DATA, ft->file_size, ft->file_id,
+                                    (uint8_t *) ft->file_name, strlen(ft->file_name), &err);
+
+        if (err != TOX_ERR_FILE_SEND_OK) {
+            char msg[MAX_STR_SIZE];
+            snprintf(msg, sizeof(msg), "File transfer for '%s' failed.", ft->file_name);
+            close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+            continue;
+        }
+    }
 }
 
-static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum, uint64_t position,
+static void chat_onFileChunkRequest(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t position,
                                     size_t length)
 {
-    if (num != self->num)
+    if (friendnum != self->num)
         return;
 
-    uint32_t idx = get_file_transfer_index(filenum);
+    struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
 
-    if (idx >= MAX_FILES)
+    if (!ft)
+        return;
+
+    if (ft->state != FILE_TRANSFER_STARTED)
         return;
 
     char msg[MAX_STR_SIZE];
-    const char *file_name = Friends.list[num].file_sender[idx].file_name;
-
-    FILE *fp = Friends.list[num].file_sender[idx].file;
-
-    if (fp == NULL) {
-        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Null file pointer.", file_name);
-        close_file_transfer(self, m, filenum, num, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
-        return;
-    }
 
     if (length == 0) {
-        snprintf(msg, sizeof(msg), "File '%s' successfully sent.", file_name);
-        print_progress_bar(self, Friends.list[num].file_sender[idx].bps, 100.0, Friends.list[num].file_sender[idx].line_id);
-        close_file_transfer(self, m, filenum, num, -1, msg, transfer_completed);
+        snprintf(msg, sizeof(msg), "File '%s' successfully sent.", ft->file_name);
+        print_progress_bar(self, ft->bps, 100.0, ft->line_id);
+        close_file_transfer(self, m, ft, -1, msg, transfer_completed);
         return;
     }
 
-    if (Friends.list[num].file_sender[idx].position != position) {
-        if (fseek(fp, position, SEEK_SET) == -1) {
-            snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Seek fail.", file_name);
-            close_file_transfer(self, m, filenum, num, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+    if (ft->file == NULL) {
+        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Null file pointer.", ft->file_name);
+        close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+        return;
+    }
+
+    if (ft->position != position) {
+        if (fseek(ft->file, position, SEEK_SET) == -1) {
+            snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Seek fail.", ft->file_name);
+            close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
             return;
         }
 
-        Friends.list[num].file_sender[idx].position = position;
+        ft->position = position;
     }
 
     uint8_t send_data[length];
-    size_t send_length = fread(send_data, 1, sizeof(send_data), fp);
+    size_t send_length = fread(send_data, 1, sizeof(send_data), ft->file);
 
     if (send_length != length) {
-        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Read fail.", file_name);
-        close_file_transfer(self, m, filenum, num, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Read fail.", ft->file_name);
+        close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
         return;
     }
 
     TOX_ERR_FILE_SEND_CHUNK err;
-    tox_file_send_chunk(m, num, filenum, position, send_data, send_length, &err);
+    tox_file_send_chunk(m, ft->friendnum, ft->filenum, position, send_data, send_length, &err);
 
     if (err != TOX_ERR_FILE_SEND_CHUNK_OK)
-        fprintf(stderr, "tox_file_send_chunk failed (error %d)\n", err);
+        fprintf(stderr, "tox_file_send_chunk failed in chat callback (error %d)\n", err);
 
-    Friends.list[num].file_sender[idx].position += send_length;
-    Friends.list[num].file_sender[idx].bps += send_length;
+    ft->position += send_length;
+    ft->bps += send_length;
+    ft->last_keep_alive = get_unix_time();
 }
 
-static void chat_onFileRecvChunk(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum, uint64_t position,
+static void chat_onFileRecvChunk(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t position,
                                  const char *data, size_t length)
 {
-    if (num != self->num)
+    if (friendnum != self->num)
         return;
 
-    uint32_t idx = get_file_transfer_index(filenum);
+    struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
 
-    if (idx >= MAX_FILES)
+    if (!ft)
+        return;
+
+    if (ft->state != FILE_TRANSFER_STARTED)
         return;
 
     char msg[MAX_STR_SIZE];
-    char file_name[MAX_STR_SIZE];
-    get_file_name(file_name, sizeof(file_name), Friends.list[num].file_receiver[idx].file_path);
 
     if (length == 0) {
-        snprintf(msg, sizeof(msg), "File '%s' successfully received.", file_name);
-        print_progress_bar(self, Friends.list[num].file_receiver[idx].bps, 100.0, Friends.list[num].file_receiver[idx].line_id);
-        close_file_transfer(self, m, filenum, num, -1, msg, transfer_completed);
+        snprintf(msg, sizeof(msg), "File '%s' successfully received.", ft->file_name);
+        print_progress_bar(self, ft->bps, 100.0, ft->line_id);
+        close_file_transfer(self, m, ft, -1, msg, transfer_completed);
         return;
     }
 
-    FILE *fp = Friends.list[num].file_receiver[idx].file;
-
-    if (fp == NULL) {
-        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Invalid file pointer.", file_name);
-        close_file_transfer(self, m, filenum, num, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+    if (ft->file == NULL) {
+        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Invalid file pointer.", ft->file_name);
+        close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
         return;
     }
 
-    if (fwrite(data, length, 1, fp) != 1) {
-        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Write fail.", file_name);
-        close_file_transfer(self, m, filenum, num, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+    if (fwrite(data, length, 1, ft->file) != 1) {
+        snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Write fail.", ft->file_name);
+        close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
         return;
     }
 
-    Friends.list[num].file_receiver[idx].bps += length;
-    Friends.list[num].file_receiver[idx].position += length;
+    ft->bps += length;
+    ft->position += length;
+    ft->last_keep_alive = get_unix_time();
 }
 
-static void chat_onFileControl(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum, TOX_FILE_CONTROL control)
+static void chat_onFileControl(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, TOX_FILE_CONTROL control)
 {
-    if (self->num != num)
+    if (friendnum != self->num)
         return;
 
-    uint32_t idx = get_file_transfer_index(filenum);
-    bool sending = filenum_is_sending(filenum);
+    struct FileTransfer *ft = get_file_transfer_struct(friendnum, filenum);
 
-    if (idx >= MAX_FILES)
+    if (!ft)
         return;
 
-    char file_name[MAX_STR_SIZE];
     char msg[MAX_STR_SIZE];
 
-    if (sending && Friends.list[num].file_sender[idx].active) {
-        snprintf(file_name, sizeof(file_name), "%s", Friends.list[num].file_sender[idx].file_name);
-    } else if (!sending && Friends.list[num].file_receiver[idx].active) {
-        get_file_name(file_name, sizeof(file_name), Friends.list[num].file_receiver[idx].file_path);
-    } else {
-        return;
-    }
-
     switch (control) {
-        case TOX_FILE_CONTROL_RESUME:
+        case TOX_FILE_CONTROL_RESUME: {
+            ft->last_keep_alive = get_unix_time();
+
             /* transfer is accepted */
-            if (sending && !Friends.list[num].file_sender[idx].started) {
-                Friends.list[num].file_sender[idx].started = true;
+            if (ft->state == FILE_TRANSFER_PENDING) {
+                ft->state = FILE_TRANSFER_STARTED;
                 line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer [%d] for '%s' accepted.",
-                                                                      idx, file_name);
+                              ft->index, ft->file_name);
                 char progline[MAX_STR_SIZE];
-                prep_prog_line(progline);
+                init_progress_bar(progline);
                 line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", progline);
-                Friends.list[num].file_sender[idx].line_id = self->chatwin->hst->line_end->id + 2;
-                sound_notify(self, silent, NT_NOFOCUS | NT_BEEP | NT_WNDALERT_2, NULL);
+                sound_notify(self, silent, NT_NOFOCUS | user_settings->bell_on_filetrans_accept | NT_WNDALERT_2, NULL);
+                ft->line_id = self->chatwin->hst->line_end->id + 2;
+            } else if (ft->state == FILE_TRANSFER_PAUSED) {    /* transfer is resumed */
+                ft->state = FILE_TRANSFER_STARTED;
             }
 
             break;
+        }
 
-        case TOX_FILE_CONTROL_PAUSE:
+        case TOX_FILE_CONTROL_PAUSE: {
+            ft->state = FILE_TRANSFER_PAUSED;
             break;
+        }
 
-        case TOX_FILE_CONTROL_CANCEL:
-            snprintf(msg, sizeof(msg), "File transfer for '%s' was aborted.", file_name);
-            close_file_transfer(self, m, filenum, num, -1, msg, notif_error);
+        case TOX_FILE_CONTROL_CANCEL: {
+            snprintf(msg, sizeof(msg), "File transfer for '%s' was aborted.", ft->file_name);
+            close_file_transfer(self, m, ft, -1, msg, notif_error);
             break;
+        }
     }
 }
 
-static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum, uint32_t kind,
-                            uint64_t file_size, const char *filename, size_t name_length)
+/* Attempts to resume a broken inbound file transfer.
+ *
+ * Returns true if resume is successful.
+ */
+static bool chat_resume_broken_ft(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum)
 {
-    if (self->num != num)
+    char msg[MAX_STR_SIZE];
+    uint8_t file_id[TOX_FILE_ID_LENGTH];
+
+    if (!tox_file_get_file_id(m, friendnum, filenum, file_id, NULL))
+        return false;
+
+    bool resuming = false;
+    struct FileTransfer *ft = NULL;
+    size_t i;
+
+    for (i = 0; i < MAX_FILES; ++i) {
+        ft = &Friends.list[friendnum].file_receiver[i];
+
+        if (ft->state == FILE_TRANSFER_INACTIVE)
+            continue;
+
+        if (memcmp(ft->file_id, file_id, TOX_FILE_ID_LENGTH) == 0) {
+            ft->filenum = filenum;
+            ft->state = FILE_TRANSFER_STARTED;
+            ft->last_keep_alive = get_unix_time();
+            resuming = true;
+            break;
+        }
+    }
+
+    if (!resuming || !ft)
+        return false;
+
+    if (!tox_file_seek(m, ft->friendnum, ft->filenum, ft->position, NULL))
+        goto on_error;
+
+    if (!tox_file_control(m, ft->friendnum, ft->filenum, TOX_FILE_CONTROL_RESUME, NULL))
+        goto on_error;
+
+    return true;
+
+on_error:
+    snprintf(msg, sizeof(msg), "File transfer for '%s' failed.", ft->file_name);
+    close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+    return false;
+}
+
+static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_t filenum, uint64_t file_size,
+                            const char *filename, size_t name_length)
+{
+    if (self->num != friendnum)
         return;
 
-    uint32_t idx = get_file_transfer_index(filenum);
+    /* first check if we need to resume a broken transfer */
+    if (chat_resume_broken_ft(self, m, friendnum, filenum))
+        return;
 
-    if (idx >= MAX_FILES) {
+    struct FileTransfer *ft = new_file_transfer(self, friendnum, filenum, FILE_TRANSFER_RECV, TOX_FILE_KIND_DATA);
+
+    if (!ft) {
+        tox_file_control(m, friendnum, filenum, TOX_FILE_CONTROL_CANCEL, NULL);
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer failed: Too many concurrent file transfers.");
         return;
     }
 
     char sizestr[32];
     bytes_convert_str(sizestr, sizeof(sizestr), file_size);
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer request for '%s' (%s)",
-                                                          filename, sizestr);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer request for '%s' (%s)", filename, sizestr);
 
-    char file_path[MAX_STR_SIZE];
+    char file_path[PATH_MAX + name_length + 1];
     size_t path_len = name_length;
 
     /* use specified download path in config if possible */
@@ -479,8 +572,9 @@ static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t file
         snprintf(file_path, sizeof(file_path), "%s", filename);
     }
 
-    if (path_len >= sizeof(Friends.list[num].file_receiver[idx].file_path)) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer faield: File name too long.");
+    if (path_len >= sizeof(file_path) || path_len >= sizeof(ft->file_path) || name_length >= sizeof(ft->file_name)) {
+        tox_file_control(m, friendnum, filenum, TOX_FILE_CONTROL_CANCEL, NULL);
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer faield: File path too long.");
         return;
     }
 
@@ -505,23 +599,25 @@ static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t file
         file_path[path_len + d_len] = '\0';
 
         if (count > 999) {
+            tox_file_control(m, friendnum, filenum, TOX_FILE_CONTROL_CANCEL, NULL);
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer failed: invalid file path.");
             return;
         }
     }
 
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Type '/savefile %d' to accept the file transfer.", idx);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Type '/savefile %d' to accept the file transfer.", ft->index);
 
-    Friends.list[num].file_receiver[idx].pending = true;
-    Friends.list[num].file_receiver[idx].file_size = file_size;
-    strcpy(Friends.list[num].file_receiver[idx].file_path, file_path);
+    ft->file_size = file_size;
+    snprintf(ft->file_path, sizeof(ft->file_path), "%s", file_path);
+    snprintf(ft->file_name, sizeof(ft->file_name), "%s", filename);
+    tox_file_get_file_id(m, friendnum, filenum, ft->file_id, NULL);
 
     if (self->active_box != -1)
-        box_notify2(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS, self->active_box,
-                    "Incoming file: %s", filename );
+        box_notify2(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS | user_settings->bell_on_filetrans,
+                    self->active_box, "Incoming file: %s", filename );
     else
-        box_notify(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS, &self->active_box, self->name,
-                    "Incoming file: %s", filename );
+        box_notify(self, transfer_pending, NT_WNDALERT_0 | NT_NOFOCUS | user_settings->bell_on_filetrans,
+                   &self->active_box, self->name, "Incoming file: %s", filename );
 }
 
 static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, uint8_t type, const char *group_pub_key,
@@ -544,7 +640,7 @@ static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, ui
     Friends.list[friendnumber].group_invite.length = length;
     Friends.list[friendnumber].group_invite.type = type;
 
-    sound_notify(self, generic_message, NT_WNDALERT_2, NULL);
+    sound_notify(self, generic_message, NT_WNDALERT_2 | user_settings->bell_on_invite, NULL);
 
     char name[TOX_MAX_NAME_LENGTH];
     get_nick_truncate(m, name, friendnumber);
@@ -558,22 +654,21 @@ static void chat_onGroupInvite(ToxWindow *self, Tox *m, int32_t friendnumber, ui
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Type \"/join\" to join the chat.");
 }
 
-/* Av Stuff */
+/* AV Stuff */
 #ifdef AUDIO
 
-void chat_onInvite (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onInvite (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
-    /* call_index is set here and reset on call end */
+    /* call is flagged active here */
+    self->is_call = true;
 
-    self->call_idx = call_index;
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Incoming audio call! Type: \"/answer\" or \"/reject\"");
 
     if (self->ringing_sound == -1)
-        sound_notify(self, call_incoming, NT_LOOP, &self->ringing_sound);
-
+        sound_notify(self, call_incoming, NT_LOOP | user_settings->bell_on_invite, &self->ringing_sound);
 
     if (self->active_box != -1)
         box_silent_notify2(self, NT_NOFOCUS | NT_WNDALERT_0, self->active_box, "Incoming audio call!");
@@ -581,53 +676,59 @@ void chat_onInvite (ToxWindow *self, ToxAv *av, int call_index)
         box_silent_notify(self, NT_NOFOCUS | NT_WNDALERT_0, &self->active_box, self->name, "Incoming audio call!");
 }
 
-void chat_onRinging (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onRinging (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if ( !self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Ringing...type \"/hangup\" to cancel it.");
 
 #ifdef SOUND_NOTIFY
+
     if (self->ringing_sound == -1)
         sound_notify(self, call_outgoing, NT_LOOP, &self->ringing_sound);
+
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onStarting (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onStarting (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if ( !self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
     init_infobox(self);
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call started! Type: \"/hangup\" to end it.");
 
+    /* call is flagged active here */
+    self->is_call = true;
+
 #ifdef SOUND_NOTIFY
     stop_sound(self->ringing_sound);
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onEnding (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onEnding (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
     kill_infobox(self);
-    self->call_idx = -1;
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call ended!");
 
+    self->is_call = false;
+
 #ifdef SOUND_NOTIFY
     stop_sound(self->ringing_sound);
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onError (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onError (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
-    self->call_idx = -1;
+    self->is_call = false;
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Error!");
 
 #ifdef SOUND_NOTIFY
@@ -635,11 +736,14 @@ void chat_onError (ToxWindow *self, ToxAv *av, int call_index)
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onStart (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onStart (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if ( !self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
+    /* call is flagged active here */
+    self->is_call = true;
+
     init_infobox(self);
 
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call started! Type: \"/hangup\" to end it.");
@@ -649,13 +753,13 @@ void chat_onStart (ToxWindow *self, ToxAv *av, int call_index)
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onCancel (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onCancel (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if ( !self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
+    self->is_call = false;
     kill_infobox(self);
-    self->call_idx = -1;
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call canceled!");
 
 #ifdef SOUND_NOTIFY
@@ -663,54 +767,27 @@ void chat_onCancel (ToxWindow *self, ToxAv *av, int call_index)
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onReject (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onReject (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self  || self->num != friend_number)
         return;
 
-    self->call_idx = -1;
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Rejected!");
+    self->is_call = false;
 
 #ifdef SOUND_NOTIFY
     stop_sound(self->ringing_sound);
 #endif /* SOUND_NOTIFY */
 }
 
-void chat_onEnd (ToxWindow *self, ToxAv *av, int call_index)
+void chat_onEnd (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    if (!self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
+    if (!self || self->num != friend_number)
         return;
 
     kill_infobox(self);
-    self->call_idx = -1;
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Call ended!");
-
-#ifdef SOUND_NOTIFY
-    stop_sound(self->ringing_sound);
-#endif /* SOUND_NOTIFY */
-}
-
-void chat_onRequestTimeout (ToxWindow *self, ToxAv *av, int call_index)
-{
-    if (!self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
-        return;
-
-    self->call_idx = -1;
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "No answer!");
-
-#ifdef SOUND_NOTIFY
-    stop_sound(self->ringing_sound);
-#endif /* SOUND_NOTIFY */
-}
-
-void chat_onPeerTimeout (ToxWindow *self, ToxAv *av, int call_index)
-{
-    if (!self || self->call_idx != call_index || self->num != toxav_get_peer_id(av, call_index, 0))
-        return;
-
-    kill_infobox(self);
-    self->call_idx = -1;
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Peer disconnected; call ended!");
+    self->is_call = false;
 
 #ifdef SOUND_NOTIFY
     stop_sound(self->ringing_sound);
@@ -723,6 +800,10 @@ static void init_infobox(ToxWindow *self)
 
     int x2, y2;
     getmaxyx(self->window, y2, x2);
+
+    if (y2 <= 0 || x2 <= 0)
+        return;
+
     (void) y2;
 
     memset(&ctx->infobox, 0, sizeof(struct infobox));
@@ -759,7 +840,7 @@ static void draw_infobox(ToxWindow *self)
     if (x2 < INFOBOX_WIDTH || y2 < INFOBOX_HEIGHT)
         return;
 
-    uint64_t curtime = get_unix_time();
+    time_t curtime = get_unix_time();
 
     /* update elapsed time string once per second */
     if (curtime > infobox->lastupdate)
@@ -796,7 +877,7 @@ static void draw_infobox(ToxWindow *self)
     wprintw(infobox->win, "%.2f\n", infobox->vad_lvl);
 
     wborder(infobox->win, ACS_VLINE, ' ', ACS_HLINE, ACS_HLINE, ACS_TTEE, ' ', ACS_LLCORNER, ' ');
-    wrefresh(infobox->win);
+    wnoutrefresh(infobox->win);
 }
 
 #endif /* AUDIO */
@@ -815,13 +896,12 @@ static void send_action(ToxWindow *self, ChatContext *ctx, Tox *m, char *action)
     char timefrmt[TIME_STR_SIZE];
     get_time_str(timefrmt, sizeof(timefrmt));
 
-    line_info_add(self, timefrmt, selfname, NULL, OUT_ACTION, 0, 0, "%s", action);
-    cqueue_add(ctx->cqueue, action, strlen(action), OUT_ACTION, ctx->hst->line_end->id + 1);
+    int id = line_info_add(self, timefrmt, selfname, NULL, OUT_ACTION, 0, 0, "%s", action);
+    cqueue_add(ctx->cqueue, action, strlen(action), OUT_ACTION, id);
 }
 
 static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 {
-
     ChatContext *ctx = self->chatwin;
     StatusBar *statusbar = self->stb;
 
@@ -829,15 +909,18 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     getyx(self->window, y, x);
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= 0)
+    if (y2 <= 0 || x2 <= 0)
         return;
 
+    if (ctx->pastemode && key == '\r')
+        key = '\n';
+
     if (self->help->active) {
         help_onKey(self, key);
         return;
     }
 
-    if (ltr) {    /* char is printable */
+    if (ltr || key == '\n') {    /* char is printable */
         input_new_char(self, key, x, y, x2, y2);
 
         if (ctx->line[0] != '/' && !ctx->self_is_typing && statusbar->connection != TOX_CONNECTION_NONE)
@@ -859,11 +942,20 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
             diff = dir_match(self, m, ctx->line, L"/sendfile");
         } else if (wcsncmp(ctx->line, L"/avatar \"", wcslen(L"/avatar \"")) == 0) {
             diff = dir_match(self, m, ctx->line, L"/avatar");
-        } else if (wcsncmp(ctx->line, L"/status ", wcslen(L"/status ")) == 0){
+        }
+
+#ifdef PYTHON
+        else if (wcsncmp(ctx->line, L"/run \"", wcslen(L"/run \"")) == 0) {
+            diff = dir_match(self, m, ctx->line, L"/run");
+        }
+
+#endif
+
+        else if (wcsncmp(ctx->line, L"/status ", wcslen(L"/status ")) == 0) {
             const char status_cmd_list[3][8] = {
-              {"online"},
-              {"away"},
-              {"busy"},
+                {"online"},
+                {"away"},
+                {"busy"},
             };
             diff = complete_line(self, status_cmd_list, 3, 8);
         } else {
@@ -872,45 +964,48 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 
         if (diff != -1) {
             if (x + diff > x2 - 1) {
-                int wlen = wcswidth(ctx->line, sizeof(ctx->line));
+                int wlen = MAX(0, wcswidth(ctx->line, sizeof(ctx->line) / sizeof(wchar_t)));
                 ctx->start = wlen < x2 ? 0 : wlen - x2 + 1;
             }
         } else {
             sound_notify(self, notif_error, 0, NULL);
         }
 
-    } else if (key == '\n') {
+    } else if (key == '\r') {
         rm_trailing_spaces_buf(ctx);
 
-        char line[MAX_STR_SIZE];
-
-        if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
-            memset(&line, 0, sizeof(line));
-
-        if (!string_is_empty(line))
+        if (!wstring_is_empty(ctx->line)) {
             add_line_to_hist(ctx);
 
-        if (line[0] == '/') {
-            if (strcmp(line, "/close") == 0) {
-                kill_chat_window(self, m);
-                return;
-            } else if (strncmp(line, "/me ", strlen("/me ")) == 0) {
-                send_action(self, ctx, m, line + strlen("/me "));
+            wstrsubst(ctx->line, L'¶', L'\n');
+
+            char line[MAX_STR_SIZE] = {0};
+
+            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
+                memset(&line, 0, sizeof(line));
+
+            if (line[0] == '/') {
+                if (strcmp(line, "/close") == 0) {
+                    kill_chat_window(self, m);
+                    return;
+                } else if (strncmp(line, "/me ", strlen("/me ")) == 0) {
+                    send_action(self, ctx, m, line + strlen("/me "));
+                } else {
+                    execute(ctx->history, self, m, line, CHAT_COMMAND_MODE);
+                }
             } else {
-                execute(ctx->history, self, m, line, CHAT_COMMAND_MODE);
+                char selfname[TOX_MAX_NAME_LENGTH];
+                tox_self_get_name(m, (uint8_t *) selfname);
+
+                size_t len = tox_self_get_name_size(m);
+                selfname[len] = '\0';
+
+                char timefrmt[TIME_STR_SIZE];
+                get_time_str(timefrmt, sizeof(timefrmt));
+
+                int id = line_info_add(self, timefrmt, selfname, NULL, OUT_MSG, 0, 0, "%s", line);
+                cqueue_add(ctx->cqueue, line, strlen(line), OUT_MSG, id);
             }
-        } else if (!string_is_empty(line)) {
-            char selfname[TOX_MAX_NAME_LENGTH];
-            tox_self_get_name(m, (uint8_t *) selfname);
-
-            size_t len = tox_self_get_name_size(m);
-            selfname[len] = '\0';
-
-            char timefrmt[TIME_STR_SIZE];
-            get_time_str(timefrmt, sizeof(timefrmt));
-
-            line_info_add(self, timefrmt, selfname, NULL, OUT_MSG, 0, 0, "%s", line);
-            cqueue_add(ctx->cqueue, line, strlen(line), OUT_MSG, ctx->hst->line_end->id + 1);
         }
 
         wclear(ctx->linewin);
@@ -927,9 +1022,15 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
+    if (y2 <= 0 || x2 <= 0)
+        return;
+
     ChatContext *ctx = self->chatwin;
 
+    pthread_mutex_lock(&Winthread.lock);
     line_info_print(self);
+    pthread_mutex_unlock(&Winthread.lock);
+
     wclear(ctx->linewin);
 
     curs_set(1);
@@ -951,9 +1052,11 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
             case TOX_USER_STATUS_NONE:
                 colour = GREEN;
                 break;
+
             case TOX_USER_STATUS_AWAY:
                 colour = YELLOW;
                 break;
+
             case TOX_USER_STATUS_BUSY:
                 colour = RED;
                 break;
@@ -1023,16 +1126,17 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
     int y, x;
     getyx(self->window, y, x);
     (void) x;
-    int new_x = ctx->start ? x2 - 1 : wcswidth(ctx->line, ctx->pos);
+    int new_x = ctx->start ? x2 - 1 : MAX(0, wcswidth(ctx->line, ctx->pos));
     wmove(self->window, y + 1, new_x);
 
-    wrefresh(self->window);
+    wnoutrefresh(self->window);
 
 #ifdef AUDIO
+
     if (ctx->infobox.active) {
         draw_infobox(self);
-        wrefresh(self->window);
     }
+
 #endif
 
     if (self->help->active)
@@ -1048,6 +1152,10 @@ static void chat_onInit(ToxWindow *self, Tox *m)
     curs_set(1);
     int x2, y2;
     getmaxyx(self->window, y2, x2);
+
+    if (y2 <= 0 || x2 <= 0)
+        exit_toxic_err("failed in chat_onInit", FATALERR_CURSES);
+
     self->x = x2;
 
     /* Init statusbar info */
@@ -1090,11 +1198,13 @@ static void chat_onInit(ToxWindow *self, Tox *m)
     char myid[TOX_ADDRESS_SIZE];
     tox_self_get_address(m, (uint8_t *) myid);
 
-    log_enable(nick, myid, Friends.list[self->num].pub_key, ctx->log, LOG_CHAT);
+    int log_ret = log_enable(nick, myid, Friends.list[self->num].pub_key, ctx->log, LOG_CHAT);
     load_chat_history(self, ctx->log);
 
     if (!Friends.list[self->num].logging_on)
         log_disable(ctx->log);
+    else if (log_ret == -1)
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
 
     execute(ctx->history, self, m, "/log", GLOBAL_COMMAND_MODE);
 
@@ -1136,10 +1246,8 @@ ToxWindow new_chat(Tox *m, uint32_t friendnum)
     ret.onCancel = &chat_onCancel;
     ret.onReject = &chat_onReject;
     ret.onEnd = &chat_onEnd;
-    ret.onRequestTimeout = &chat_onRequestTimeout;
-    ret.onPeerTimeout = &chat_onPeerTimeout;
 
-    ret.call_idx = -1;
+    ret.is_call = false;
     ret.device_selection[0] = ret.device_selection[1] = -1;
     ret.ringing_sound = -1;
 #endif /* AUDIO */

src/chat_commands.c

@@ -45,38 +45,37 @@ void cmd_cancelfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*ar
 
     char msg[MAX_STR_SIZE];
     const char *inoutstr = argv[1];
-    int idx = atoi(argv[2]);
+    long int idx = strtol(argv[2], NULL, 10);
 
-    if (idx >= MAX_FILES || idx < 0) {
+    if ((idx == 0 && strcmp(argv[2], "0")) || idx >= MAX_FILES || idx < 0) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid file ID.");
         return;
     }
 
-    if (strcasecmp(inoutstr, "in") == 0) {    /* cancel an incoming file transfer */
-        if (!Friends.list[self->num].file_receiver[idx].active) {
-            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid file ID.");
-            return;
-        }
+    struct FileTransfer *ft = NULL;
 
-        const char *file_path = Friends.list[self->num].file_receiver[idx].file_path;
-        char file_name[MAX_STR_SIZE];
-        get_file_name(file_name, sizeof(file_name), file_path);
-        snprintf(msg, sizeof(msg), "File transfer for '%s' canceled.", file_name);
-        close_file_transfer(self, m, get_file_receiver_filenum(idx), self->num, TOX_FILE_CONTROL_CANCEL, msg, silent);
-        return;
-    } else if (strcasecmp(inoutstr, "out") == 0) {    /* cancel an outgoing file transfer */
-        if (!Friends.list[self->num].file_sender[idx].active) {
-            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid file ID.");
-            return;
-        }
-
-        snprintf(msg, sizeof(msg), "File transfer for '%s' canceled.", Friends.list[self->num].file_sender[idx].file_name);
-        close_file_transfer(self, m, idx, self->num, TOX_FILE_CONTROL_CANCEL, msg, silent);
-        return;
+    /* cancel an incoming file transfer */
+    if (strcasecmp(inoutstr, "in") == 0) {
+        ft = get_file_transfer_struct_index(self->num, idx, FILE_TRANSFER_RECV);
+    } else if (strcasecmp(inoutstr, "out") == 0) {
+        ft = get_file_transfer_struct_index(self->num, idx, FILE_TRANSFER_SEND);
     } else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Type must be 'in' or 'out'.");
         return;
     }
+
+    if (!ft) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid file ID.");
+        return;
+    }
+
+    if (ft->state == FILE_TRANSFER_INACTIVE) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid file ID.");
+        return;
+    }
+
+    snprintf(msg, sizeof(msg), "File transfer for '%s' aborted.", ft->file_name);
+    close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, silent);
 }
 
 void cmd_groupinvite(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@@ -86,15 +85,17 @@ void cmd_groupinvite(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
         return;
     }
 
-    int groupnum = atoi(argv[1]);
+    long int groupnum = strtol(argv[1], NULL, 10);
 
-    if (groupnum == 0 && strcmp(argv[1], "0")) {    /* atoi returns 0 value on invalid input */
+    if ((groupnum == 0 && strcmp(argv[1], "0")) || groupnum < 0 || groupnum == LONG_MAX) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid group number.");
         return;
     }
 
-    if (tox_invite_friend(m, self->num, groupnum) == -1) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to invite contact to group.");
+    TOX_ERR_CONFERENCE_INVITE err;
+
+    if (!tox_conference_invite(m, self->num, groupnum, &err)) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to invite contact to group (error %d)", err);
         return;
     }
 
@@ -117,24 +118,23 @@ void cmd_join_group(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*ar
         return;
     }
 
-    int groupnum = -1;
+    if (type != TOX_CONFERENCE_TYPE_TEXT) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Toxic does not support audio groups.");
+        return;
+    }
 
-    if (type == TOX_GROUPCHAT_TYPE_TEXT)
-        groupnum = tox_join_groupchat(m, self->num, (uint8_t *) groupkey, length);
-#ifdef AUDIO
-    else
-        groupnum = toxav_join_av_groupchat(m, self->num, (uint8_t *) groupkey, length,
-                                           write_device_callback_group, NULL);
-#endif
+    TOX_ERR_CONFERENCE_JOIN err;
 
-    if (groupnum == -1) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Group chat instance failed to initialize.");
+    uint32_t groupnum = tox_conference_join(m, self->num, (uint8_t *) groupkey, length, &err);
+
+    if (err != TOX_ERR_CONFERENCE_JOIN_OK) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Group chat instance failed to initialize (error %d)", err);
         return;
     }
 
     if (init_groupchat_win(prompt, m, groupnum, type) == -1) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Group chat window failed to initialize.");
-        tox_del_groupchat(m, groupnum);
+        tox_conference_delete(m, groupnum, NULL);
         return;
     }
 
@@ -147,47 +147,51 @@ void cmd_savefile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
         return;
     }
 
-    int idx = atoi(argv[1]);
+    long int idx = strtol(argv[1], NULL, 10);
 
-    if ((idx == 0 && strcmp(argv[1], "0")) || idx >= MAX_FILES) {
+    if ((idx == 0 && strcmp(argv[1], "0")) || idx < 0 || idx >= MAX_FILES) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "No pending file transfers with that ID.");
         return;
     }
 
-    uint32_t filenum = get_file_receiver_filenum(idx);
+    struct FileTransfer *ft = get_file_transfer_struct_index(self->num, idx, FILE_TRANSFER_RECV);
 
-    if (!Friends.list[self->num].file_receiver[idx].pending) {
+    if (!ft) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "No pending file transfers with that ID.");
         return;
     }
 
-    const char *file_path = Friends.list[self->num].file_receiver[idx].file_path;
+    if (ft->state != FILE_TRANSFER_PENDING) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "No pending file transfers with that ID.");
+        return;
+    }
+
+    if ((ft->file = fopen(ft->file_path, "a")) == NULL) {
+        const char *msg =  "File transfer failed: Invalid file path.";
+        close_file_transfer(self, m, ft, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
+        return;
+    }
 
     TOX_ERR_FILE_CONTROL err;
-    tox_file_control(m, self->num, filenum, TOX_FILE_CONTROL_RESUME, &err);
+    tox_file_control(m, self->num, ft->filenum, TOX_FILE_CONTROL_RESUME, &err);
 
     if (err != TOX_ERR_FILE_CONTROL_OK)
         goto on_recv_error;
 
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Saving file [%d] as: '%s'", idx, file_path);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Saving file [%d] as: '%s'", idx, ft->file_path);
 
     /* prep progress bar line */
     char progline[MAX_STR_SIZE];
-    prep_prog_line(progline);
+    init_progress_bar(progline);
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", progline);
-    Friends.list[self->num].file_receiver[idx].line_id = self->chatwin->hst->line_end->id + 2;
-    Friends.list[self->num].file_receiver[idx].pending = false;
 
-    if ((Friends.list[self->num].file_receiver[idx].file = fopen(file_path, "a")) == NULL) {
-        tox_file_control(m, self->num, filenum, TOX_FILE_CONTROL_CANCEL, NULL);
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer failed: Invalid file path.");
-    } else {
-        Friends.list[self->num].file_receiver[idx].active = true;
-    }
+    ft->line_id = self->chatwin->hst->line_end->id + 2;
+    ft->state = FILE_TRANSFER_STARTED;
 
     return;
 
 on_recv_error:
+
     switch (err) {
         case TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND:
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "File transfer failed: Friend not found.");
@@ -252,37 +256,35 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
     }
 
     char file_name[TOX_MAX_FILENAME_LENGTH];
-    get_file_name(file_name, sizeof(file_name), path);
-    size_t namelen = strlen(file_name);
+    size_t namelen = get_file_name(file_name, sizeof(file_name), path);
 
     TOX_ERR_FILE_SEND err;
-    uint32_t filenum = tox_file_send(m, self->num, TOX_FILE_KIND_DATA, (uint64_t) filesize,
-                                     NULL, (uint8_t *) file_name, namelen, &err);
+    uint32_t filenum = tox_file_send(m, self->num, TOX_FILE_KIND_DATA, (uint64_t) filesize, NULL,
+                                     (uint8_t *) file_name, namelen, &err);
 
     if (err != TOX_ERR_FILE_SEND_OK)
         goto on_send_error;
 
-    uint32_t idx = get_file_transfer_index(filenum);
+    struct FileTransfer *ft = new_file_transfer(self, self->num, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_DATA);
 
-    if (idx >= MAX_FILES) {
-        errmsg = "File transfer failed: Too many concurrent file transfers";
+    if (!ft) {
+        err = TOX_ERR_FILE_SEND_TOO_MANY;
         goto on_send_error;
     }
 
-    memcpy(Friends.list[self->num].file_sender[idx].file_name, file_name, namelen + 1);
-    Friends.list[self->num].file_sender[idx].active = true;
-    Friends.list[self->num].file_sender[idx].started = false;
-    Friends.list[self->num].file_sender[idx].file = file_to_send;
-    Friends.list[self->num].file_sender[idx].timestamp = get_unix_time();
-    Friends.list[self->num].file_sender[idx].file_size = filesize;
+    memcpy(ft->file_name, file_name, namelen + 1);
+    ft->file = file_to_send;
+    ft->file_size = filesize;
+    tox_file_get_file_id(m, self->num, filenum, ft->file_id, NULL);
 
     char sizestr[32];
     bytes_convert_str(sizestr, sizeof(sizestr), filesize);
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Sending file [%d]: '%s' (%s)", idx, file_name, sizestr);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Sending file [%d]: '%s' (%s)", filenum, file_name, sizestr);
 
     return;
 
 on_send_error:
+
     switch (err) {
         case TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND:
             errmsg = "File transfer failed: Invalid friend.";
@@ -301,7 +303,7 @@ on_send_error:
             break;
 
         default:
-            errmsg = "File transfer failed";
+            errmsg = "File transfer failed.";
             break;
     }
 

src/chat_commands.h

@@ -41,6 +41,12 @@ void cmd_cancel(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZ
 void cmd_ccur_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_mute(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_sense(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_bitrate(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 #endif /* AUDIO */
 
+#ifdef VIDEO
+void cmd_video(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_ccur_video_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+#endif /* VIDEO */
+
 #endif /* #define CHAT_COMMANDS_H */

src/configdir.c

@@ -31,8 +31,9 @@
 
 #include "toxic.h"
 #include "configdir.h"
+#include "misc_tools.h"
 
-/* get the user's home directory */
+/* get the user's home directory. */
 void get_home_dir(char *home, int size)
 {
     struct passwd pwd;
@@ -69,8 +70,8 @@ char *get_user_config_dir(void)
     char home[NSS_BUFLEN_PASSWD] = {0};
     get_home_dir(home, sizeof(home));
 
-    char *user_config_dir;
-    size_t len;
+    char *user_config_dir = NULL;
+    size_t len = 0;
 
 # if defined(__APPLE__)
     len = strlen(home) + strlen("/Library/Application Support") + 1;
@@ -82,9 +83,9 @@ char *get_user_config_dir(void)
     snprintf(user_config_dir, len, "%s/Library/Application Support", home);
 # else /* __APPLE__ */
 
-    const char *tmp;
+    const char *tmp = getenv("XDG_CONFIG_HOME");
 
-    if (!(tmp = getenv("XDG_CONFIG_HOME"))) {
+    if (tmp == NULL) {
         len = strlen(home) + strlen("/.config") + 1;
         user_config_dir = malloc(len);
 
@@ -101,8 +102,10 @@ char *get_user_config_dir(void)
     return user_config_dir;
 }
 
-/*
- * Creates the config and chatlog directories.
+/* Creates the config and chatlog directories.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
  */
 int create_user_config_dirs(char *path)
 {

src/configdir.h

@@ -34,8 +34,23 @@
 #define S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)
 #endif
 
+/**
+ * @brief Get the user's config directory.
+ *
+ * This is without a trailing slash. Resulting string must be freed.
+ *
+ * @return The users config dir or NULL on error.
+ */
 char *get_user_config_dir(void);
+
+/* get the user's home directory. */
 void get_home_dir(char *home, int size);
+
+/* Creates the config and chatlog directories.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
 int create_user_config_dirs(char *path);
 
 #endif /* #define CONFIGDIR_H */

src/curl_util.c

@@ -0,0 +1,93 @@
+/*  curl_util.c
+ *
+ *
+ *  Copyright (C) 2016 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/>.
+ *
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include <curl/curl.h>
+#include <tox/tox.h>
+
+#include "curl_util.h"
+
+/* Sets proxy info for given CURL handler.
+ *
+ * Returns 0 on success or if no proxy is set by the client.
+ * Returns -1 if proxy info is invalid.
+ * Returns an int > 0 on curl error (see: https://curl.haxx.se/libcurl/c/libcurl-errors.html)
+ */
+int set_curl_proxy(CURL *c_handle, const char *proxy_address, uint16_t port, uint8_t proxy_type)
+{
+    if (proxy_type == TOX_PROXY_TYPE_NONE)
+        return 0;
+
+    if (proxy_address == NULL || port == 0) {
+        return -1;
+    }
+
+    int ret = curl_easy_setopt(c_handle, CURLOPT_PROXYPORT, (long) port);
+
+    if (ret != CURLE_OK) {
+        return ret;
+    }
+
+    long int type = proxy_type == TOX_PROXY_TYPE_SOCKS5 ? CURLPROXY_SOCKS5_HOSTNAME : CURLPROXY_HTTP;
+
+    ret = curl_easy_setopt(c_handle, CURLOPT_PROXYTYPE, type);
+
+    if (ret != CURLE_OK) {
+        return ret;
+    }
+
+    ret = curl_easy_setopt(c_handle, CURLOPT_PROXY, proxy_address);
+
+    if (ret != CURLE_OK) {
+        return ret;
+    }
+
+    return 0;
+}
+
+/* Callback function for CURL to write received data.
+ *
+ * This function will append data from an http request to the data buffer
+ * until the request is complete or the buffer is full. Buffer will be null terminated.
+ *
+ * Returns number of bytes received from http request on success (don't change this).
+ * Returns 0 if data exceeds buffer size.
+ */
+size_t curl_cb_write_data(void *data, size_t size, size_t nmemb, void *user_pointer)
+{
+    struct Recv_Curl_Data *recv_data = (struct Recv_Curl_Data *) user_pointer;
+
+    size_t length = size * nmemb;
+    size_t total_size = length + recv_data->length;
+
+    if (total_size > MAX_RECV_CURL_DATA_SIZE) {
+        return 0;
+    }
+
+    memcpy(recv_data->data + recv_data->length, data, length);
+    recv_data->data[total_size] = '\0';
+    recv_data->length += length;
+
+    return length;
+}

src/curl_util.h

@@ -0,0 +1,55 @@
+/*  curl_util.h
+ *
+ *
+ *  Copyright (C) 2016 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 CURL_UTIL_H
+#define CURL_UTIL_H
+
+/* List based on Mozilla's recommended configurations for modern browsers */
+#define TLS_CIPHER_SUITE_LIST "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK"
+
+/* Max size of an http response that we can store in Recv_Data */
+#define MAX_RECV_CURL_DATA_SIZE 32767
+
+/* Holds data received from curl lookup */
+struct Recv_Curl_Data {
+    char data[MAX_RECV_CURL_DATA_SIZE + 1];   /* Data received from curl write data callback */
+    size_t length;  /* Total number of bytes written to data buffer (doesn't include null) */
+};
+
+/* Sets proxy info for given CURL handler.
+ *
+ * Returns 0 on success or if no proxy is set by the client.
+ * Returns -1 if proxy info is invalid.
+ * Returns an int > 0 on curl error (see: https://curl.haxx.se/libcurl/c/libcurl-errors.html)
+ */
+int set_curl_proxy(CURL *c_handle, const char *proxy_address, uint16_t port, uint8_t proxy_type);
+
+/* Callback function for CURL to write received data.
+ *
+ * This function will append data from an http request to the data buffer
+ * until the request is complete or the buffer is full. Buffer will be null terminated.
+ *
+ * Returns size of bytes written to the data buffer.
+ */
+size_t curl_cb_write_data(void *data, size_t size, size_t nmemb, void *user_pointer);
+
+#endif  /* CURL_UTIL_H */

src/dns.c

@@ -1,428 +0,0 @@
-/*  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/>.
- *
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h> /* for u_char */
-#include <netinet/in.h>
-#include <resolv.h>
-
-#ifdef __APPLE__
-    #include <arpa/nameser_compat.h>
-#else
-    #include <arpa/nameser.h>
-#endif  /* ifdef __APPLE__ */
-
-#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"
-#include "configdir.h"
-
-#define DNS3_KEY_SIZE 32
-#define MAX_DNS_REQST_SIZE 255
-#define TOX_DNS3_TXT_PREFIX "v=tox3;id="
-
-extern struct Winthread Winthread;
-extern struct dns3_servers dns3_servers;
-extern struct arg_opts arg_opts;
-
-#define NUM_DNS3_BACKUP_SERVERS 2
-
-/* Hardcoded backup in case domain list is not loaded */
-static struct dns3_server_backup {
-    const char *name;
-    char key[DNS3_KEY_SIZE];
-} dns3_servers_backup[] = {
-    {
-        "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;
-    char id_bin[TOX_ADDRESS_SIZE];
-    char addr[MAX_STR_SIZE];
-    char msg[MAX_STR_SIZE];
-    uint8_t busy;
-    Tox *m;
-} t_data;
-
-static struct dns_thread {
-    pthread_t tid;
-    pthread_attr_t attr;
-} dns_thread;
-
-
-#define MAX_DNS_SERVERS 50
-#define MAX_DOMAIN_SIZE 32
-#define MAX_DNS_LINE MAX_DOMAIN_SIZE + (DNS3_KEY_SIZE * 2) + 3
-
-struct dns3_servers {
-    bool loaded;
-    int lines;
-    char names[MAX_DNS_SERVERS][MAX_DOMAIN_SIZE];
-    char keys[MAX_DNS_SERVERS][DNS3_KEY_SIZE];
-} dns3_servers;
-
-static int load_dns_domainlist(const char *path)
-{
-    FILE *fp = fopen(path, "r");
-
-    if (fp == NULL)
-        return -1;
-
-    char line[MAX_DNS_LINE];
-
-    while (fgets(line, sizeof(line), fp) && dns3_servers.lines < MAX_DNS_SERVERS) {
-        int linelen = strlen(line);
-
-        if (linelen < DNS3_KEY_SIZE * 2 + 5)
-            continue;
-
-        if (line[linelen - 1] == '\n')
-            line[--linelen] = '\0';
-
-        const char *name = strtok(line, " ");
-        const char *keystr = strtok(NULL, " ");
-
-        if (name == NULL || keystr == NULL)
-            continue;
-
-        if (strlen(keystr) != DNS3_KEY_SIZE * 2)
-            continue;
-
-        snprintf(dns3_servers.names[dns3_servers.lines], sizeof(dns3_servers.names[dns3_servers.lines]), "%s", name);
-        int res = hex_string_to_bytes(dns3_servers.keys[dns3_servers.lines], DNS3_KEY_SIZE, keystr);
-
-        if (res == -1)
-            continue;
-
-        ++dns3_servers.lines;
-    }
-
-    fclose(fp);
-
-    if (dns3_servers.lines < 1)
-        return -2;
-
-    return 0;
-}
-
-static int dns_error(ToxWindow *self, const char *errmsg)
-{
-    pthread_mutex_lock(&Winthread.lock);
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "User lookup failed: %s", errmsg);
-    pthread_mutex_unlock(&Winthread.lock);
-
-    return -1;
-}
-
-static void killdns_thread(void *dns_obj)
-{
-    if (dns_obj)
-        tox_dns3_kill(dns_obj);
-
-    memset(&t_data, 0, sizeof(struct thread_data));
-    pthread_attr_destroy(&dns_thread.attr);
-    pthread_exit(NULL);
-}
-
-/* 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, char *buf)
-{
-    uint8_t *ans_pt = answer + sizeof(HEADER);
-    uint8_t *ans_end = answer + ans_len;
-    char 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, "DNS reply was too short.");
-
-    int type;
-    GETSHORT(type, ans_pt);
-
-    if (type != T_TXT)
-        return dns_error(self, "Broken DNS 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, "DNS 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, "DNS response failed.");
-
-    uint32_t txt_len = *ans_pt;
-
-    if (!size || txt_len >= size || !txt_len)
-        return dns_error(self, "No record found.");
-
-    if (txt_len > MAX_DNS_REQST_SIZE)
-        return dns_error(self, "Invalid DNS response.");
-
-    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(const char *addr, char *namebuf, char *dombuf)
-{
-    char tmpaddr[MAX_STR_SIZE];
-    char *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);
-}
-
-/* matches input domain name with domains in list and obtains key. Return 0 on success, -1 on failure */
-static int get_domain_match(char *pubkey, char *domain, const char *inputdomain)
-{
-    /* check server list first */
-    int i;
-    bool match = false;
-
-    for (i = 0; i < dns3_servers.lines; ++i) {
-        if (strcmp(dns3_servers.names[i], inputdomain) == 0) {
-            memcpy(pubkey, dns3_servers.keys[i], DNS3_KEY_SIZE);
-            snprintf(domain, MAX_DOMAIN_SIZE, "%s", dns3_servers.names[i]);
-            match = true;
-            break;
-        }
-    }
-
-    /* fall back to hard-coded domains on server list failure */
-    if (!match) {
-        for (i = 0; i < NUM_DNS3_BACKUP_SERVERS; ++i) {
-            if (strcmp(dns3_servers_backup[i].name, inputdomain) == 0) {
-                memcpy(pubkey, dns3_servers_backup[i].key, DNS3_KEY_SIZE);
-                snprintf(domain, MAX_DOMAIN_SIZE, "%s", dns3_servers_backup[i].name);
-                match = true;
-                break;
-            }
-        }
-
-        if (!match)
-            return -1;
-    }
-
-    return 0;
-}
-
-/* Does DNS lookup for addr and puts resulting tox id in id_bin. */
-void *dns3_lookup_thread(void *data)
-{
-    ToxWindow *self = t_data.self;
-
-    char inputdomain[MAX_STR_SIZE];
-    char name[MAX_STR_SIZE];
-
-    int namelen = parse_addr(t_data.addr, name, inputdomain);
-
-    if (namelen == -1) {
-        dns_error(self, "Must be a Tox ID or an address in the form username@domain");
-        killdns_thread(NULL);
-    }
-
-    char DNS_pubkey[DNS3_KEY_SIZE];
-    char domain[MAX_DOMAIN_SIZE];
-
-    int match = get_domain_match(DNS_pubkey, domain, inputdomain);
-
-    if (match == -1) {
-        dns_error(self, "Domain not found.");
-        killdns_thread(NULL);
-    }
-
-    void *dns_obj = tox_dns3_new((uint8_t *) DNS_pubkey);
-
-    if (dns_obj == NULL) {
-        dns_error(self, "Core failed to create DNS object.");
-        killdns_thread(NULL);
-    }
-
-    char string[MAX_DNS_REQST_SIZE + 1];
-    uint32_t request_id;
-
-    int str_len = tox_generate_dns3_string(dns_obj, (uint8_t *) string, sizeof(string), &request_id,
-                                           (uint8_t *) name, namelen);
-
-    if (str_len == -1) {
-        dns_error(self, "Core failed to generate DNS3 string.");
-        killdns_thread(dns_obj);
-    }
-
-    string[str_len] = '\0';
-
-    u_char answer[PACKETSZ];
-    char d_string[MAX_DOMAIN_SIZE + MAX_DNS_REQST_SIZE + 10];
-
-    /* format string and create dns query */
-    snprintf(d_string, sizeof(d_string), "_%s._tox.%s", string, domain);
-    int ans_len = res_query(d_string, C_IN, T_TXT, answer, sizeof(answer));
-
-    if (ans_len <= 0) {
-        dns_error(self, "DNS query failed.");
-        killdns_thread(dns_obj);
-    }
-
-    char ans_id[MAX_DNS_REQST_SIZE + 1];
-
-    /* extract TXT from DNS response */
-    if (parse_dns_response(self, answer, ans_len, ans_id) == -1)
-        killdns_thread(dns_obj);
-
-    char encrypted_id[MAX_DNS_REQST_SIZE + 1];
-    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.");
-        killdns_thread(dns_obj);
-    }
-
-    memcpy(encrypted_id, ans_id + prfx_len, ans_len - prfx_len);
-
-    if (tox_decrypt_dns3_TXT(dns_obj, (uint8_t *) t_data.id_bin, (uint8_t *) encrypted_id,
-                             strlen(encrypted_id), request_id) == -1) {
-        dns_error(self, "Core failed to decrypt DNS response.");
-        killdns_thread(dns_obj);
-    }
-
-    pthread_mutex_lock(&Winthread.lock);
-    cmd_add_helper(self, t_data.m, t_data.id_bin, t_data.msg);
-    pthread_mutex_unlock(&Winthread.lock);
-
-    killdns_thread(dns_obj);
-    return 0;
-}
-
-/* creates new thread for dns3 lookup. Only allows one lookup at a time. */
-void dns3_lookup(ToxWindow *self, Tox *m, const char *id_bin, const char *addr, const char *msg)
-{
-    if (arg_opts.proxy_type != TOX_PROXY_TYPE_NONE && arg_opts.force_tcp) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "DNS lookups are disabled.");
-        return;
-    }
-
-    if (t_data.busy) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Please wait for previous user lookup to finish.");
-        return;
-    }
-
-    if (!dns3_servers.loaded) {
-        const char *path = arg_opts.dns_path[0] ? arg_opts.dns_path : PACKAGE_DATADIR "/DNSservers";
-        dns3_servers.loaded = true;
-        int ret = load_dns_domainlist(path);
-
-        if (ret < 0) {
-            const char *errmsg = "DNS server list failed to load with error code %d. Falling back to hard-coded list.";
-            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, errmsg, ret);
-        }
-    }
-
-    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.self = self;
-    t_data.m = m;
-    t_data.busy = 1;
-
-    if (pthread_attr_init(&dns_thread.attr) != 0) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, "Error: DNS thread attr failed to init");
-        memset(&t_data, 0, sizeof(struct thread_data));
-        return;
-    }
-
-    if (pthread_attr_setdetachstate(&dns_thread.attr, PTHREAD_CREATE_DETACHED) != 0) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, "Error: DNS thread attr failed to set");
-        pthread_attr_destroy(&dns_thread.attr);
-        memset(&t_data, 0, sizeof(struct thread_data));
-        return;
-    }
-
-    if (pthread_create(&dns_thread.tid, &dns_thread.attr, dns3_lookup_thread, NULL) != 0) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, "Error: DNS thread failed to init");
-        pthread_attr_destroy(&dns_thread.attr);
-        memset(&t_data, 0, sizeof(struct thread_data));
-        return;
-    }
-}

src/execute.c

@@ -33,6 +33,7 @@
 #include "line_info.h"
 #include "misc_tools.h"
 #include "notify.h"
+#include "api.h"
 
 struct cmd_func {
     const char *name;
@@ -51,8 +52,10 @@ static struct cmd_func global_commands[] = {
     { "/help",      cmd_prompt_help   },
     { "/log",       cmd_log           },
     { "/myid",      cmd_myid          },
+    { "/myqr",      cmd_myqr          },
     { "/nick",      cmd_nick          },
     { "/note",      cmd_note          },
+    { "/nospam",    cmd_nospam        },
     { "/q",         cmd_quit          },
     { "/quit",      cmd_quit          },
     { "/requests",  cmd_requests      },
@@ -61,6 +64,13 @@ static struct cmd_func global_commands[] = {
     { "/lsdev",     cmd_list_devices  },
     { "/sdev",      cmd_change_device },
 #endif /* AUDIO */
+#ifdef VIDEO
+    { "/lsvdev",    cmd_list_video_devices },
+    { "/svdev",    cmd_change_video_device },
+#endif /* VIDEO */
+#ifdef PYTHON
+    { "/run",       cmd_run           },
+#endif /* PYTHON */
     { NULL,         NULL              },
 };
 
@@ -77,7 +87,11 @@ static struct cmd_func chat_commands[] = {
     { "/hangup",    cmd_hangup      },
     { "/mute",      cmd_mute        },
     { "/sense",     cmd_sense       },
+    { "/bitrate",   cmd_bitrate     },
 #endif /* AUDIO */
+#ifdef VIDEO
+    { "/video",     cmd_video       },
+#endif /* VIDEO */
     { NULL,         NULL            },
 };
 
@@ -177,11 +191,19 @@ void execute(WINDOW *w, ToxWindow *self, Tox *m, const char *input, int mode)
         case GROUPCHAT_COMMAND_MODE:
             if (do_command(w, self, m, num_args, group_commands, args) == 0)
                 return;
+
             break;
     }
 
     if (do_command(w, self, m, num_args, global_commands, args) == 0)
         return;
 
+#ifdef PYTHON
+
+    if (do_plugin_command(num_args, args) == 0)
+        return;
+
+#endif
+
     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid command.");
 }

src/file_senders.c

@@ -1,297 +0,0 @@
-/*  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/>.
- *
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <time.h>
-#include <unistd.h>
-
-#include "toxic.h"
-#include "windows.h"
-#include "friendlist.h"
-#include "file_senders.h"
-#include "line_info.h"
-#include "misc_tools.h"
-#include "notify.h"
-
-FileSender file_senders[MAX_FILES];
-uint8_t max_file_senders_index;
-uint8_t num_active_file_senders;
-extern FriendsList Friends;
-
-#define NUM_PROG_MARKS 50    /* number of "#"'s in file transfer progress bar. Keep well below MAX_STR_SIZE */
-
-/* creates initial progress line that will be updated during file transfer.
-   Assumes progline is of size MAX_STR_SIZE */
-void prep_prog_line(char *progline)
-{
-    strcpy(progline, "0.0 B/s [");
-    int i;
-
-    for (i = 0; i < NUM_PROG_MARKS; ++i)
-        strcat(progline, "-");
-
-    strcat(progline, "] 0%");
-}
-
-/* prints a progress bar for file transfers.
-   if friendnum is -1 we're sending the file, otherwise we're receiving.  */
-void print_progress_bar(ToxWindow *self, int idx, int friendnum, double pct_done)
-{
-    double bps;
-    uint32_t line_id;
-
-    if (friendnum < 0) {
-        bps = file_senders[idx].bps;
-        line_id = file_senders[idx].line_id;
-    } else {
-        bps = Friends.list[friendnum].file_receiver[idx].bps;
-        line_id = Friends.list[friendnum].file_receiver[idx].line_id;
-    }
-
-    char msg[MAX_STR_SIZE];
-    bytes_convert_str(msg, sizeof(msg), bps);
-    strcat(msg, "/s [");
-
-    int n = pct_done / (100 / NUM_PROG_MARKS);
-    int i, j;
-
-    for (i = 0; i < n; ++i)
-        strcat(msg, "#");
-
-    for (j = i; j < NUM_PROG_MARKS; ++j)
-        strcat(msg, "-");
-
-    strcat(msg, "] ");
-
-    char pctstr[16];
-    const char *frmt = pct_done == 100 ? "%.f%%" : "%.1f%%";
-    snprintf(pctstr, sizeof(pctstr), frmt, pct_done);
-    strcat(msg, pctstr);
-
-    line_info_set(self, line_id, msg);
-}
-
-/* refreshes active file receiver status bars */
-static void refresh_recv_prog(Tox *m)
-{
-    int i;
-    uint64_t curtime = get_unix_time();
-
-    for (i = 2; i < MAX_WINDOWS_NUM; ++i) {
-        ToxWindow *toxwin = get_window_ptr(i);
-
-        if (toxwin == NULL || !toxwin->is_chat)
-            continue;
-
-        int fnum = toxwin->num;
-        int j;
-
-        for (j = 0; j < MAX_FILES; ++j) {
-            if (!Friends.list[fnum].file_receiver[j].active)
-                continue;
-
-            int filenum = Friends.list[fnum].file_receiver[j].filenum;
-            double remain = (double) tox_file_data_remaining(m, fnum, filenum, 1);
-
-            /* must be called once per second */
-            if (timed_out(Friends.list[fnum].file_receiver[filenum].last_progress, curtime, 1)) {
-                Friends.list[fnum].file_receiver[filenum].last_progress = curtime;
-                uint64_t size = Friends.list[fnum].file_receiver[filenum].size;
-                double pct_done = remain > 0 ? (1 - (remain / size)) * 100 : 100;
-                print_progress_bar(toxwin, filenum, fnum, pct_done);
-                Friends.list[fnum].file_receiver[filenum].bps = 0;
-            }
-        }
-    }
-}
-
-/* refreshes active file sender status bars */
-static void refresh_sender_prog(Tox *m)
-{
-    int i;
-    uint64_t curtime = get_unix_time();
-
-    for (i = 0; i < max_file_senders_index; ++i) {
-        if (!file_senders[i].active || file_senders[i].finished)
-            continue;
-
-        int filenum = file_senders[i].filenum;
-        uint32_t friendnum = file_senders[i].friendnum;
-        double remain = (double) tox_file_data_remaining(m, friendnum, filenum, 0);
-
-        /* must be called once per second */
-        if (timed_out(file_senders[i].last_progress, curtime, 1)) {
-            file_senders[i].last_progress = curtime;
-            double pct_done = remain > 0 ? (1 - (remain / file_senders[i].size)) * 100 : 100;
-            print_progress_bar(file_senders[i].toxwin, i, -1, pct_done);
-            file_senders[i].bps = 0;
-        }
-    }
-}
-
-static void set_max_file_senders_index(void)
-{
-    int j;
-
-    for (j = max_file_senders_index; j > 0; --j) {
-        if (file_senders[j - 1].active)
-            break;
-    }
-
-    max_file_senders_index = j;
-}
-
-/* called whenever a file sender is opened or closed */
-void reset_file_sender_queue(void)
-{
-    int i;
-    int pos = 0;
-
-    for (i = 0; i < max_file_senders_index; ++i) {
-        if (file_senders[i].active)
-            file_senders[i].queue_pos = pos++;
-    }
-}
-
-/* set CTRL to -1 if we don't want to send a control signal.
-   set msg to NULL if we don't want to display a message */
-void close_file_sender(ToxWindow *self, Tox *m, int i, const char *msg, int CTRL, int filenum, uint32_t friendnum)
-{
-    if (msg != NULL)
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", msg);
-
-    if (CTRL > 0)
-        tox_file_send_control(m, friendnum, 0, filenum, CTRL, 0, 0);
-
-    fclose(file_senders[i].file);
-    memset(&file_senders[i], 0, sizeof(FileSender));
-    set_max_file_senders_index();
-    reset_file_sender_queue();
-    --num_active_file_senders;
-}
-
-void close_all_file_senders(Tox *m)
-{
-    uint8_t i;
-
-    for (i = 0; i < max_file_senders_index; ++i) {
-        if (file_senders[i].active) {
-            fclose(file_senders[i].file);
-            tox_file_send_control(m, file_senders[i].friendnum, 0, file_senders[i].filenum,
-                                  TOX_FILECONTROL_KILL, 0, 0);
-            memset(&file_senders[i], 0, sizeof(FileSender));
-        }
-
-        set_max_file_senders_index();
-    }
-}
-
-static void send_file_data(ToxWindow *self, Tox *m, uint8_t i, uint32_t friendnum, uint32_t filenum,
-                           const char *filename)
-{
-    FILE *fp = file_senders[i].file;
-
-    while (true) {
-        TOX_ERR_FILE_SEND_CHUNK err;
-        if (!tox_file_send_chunk(m, friendnum, filenum, (uint8_t *) file_senders[i].nextpiece,
-                                 file_senders[i].piecelen, &err) {
-            fprintf(stderr, "tox_file_send_chunk failed with error %d\n", err);
-            return;
-        }
-
-        file_senders[i].timestamp = get_unix_time();
-        file_senders[i].bps += file_senders[i].piecelen;
-        file_senders[i].piecelen = fread(file_senders[i].nextpiece, 1,
-                                         tox_file_data_size(m, friendnum), fp);
-
-        /* note: file sender is closed in chat_onFileControl callback after receiving reply */
-        if (file_senders[i].piecelen == 0) {
-            if (feof(fp) != 0) {   /* make sure we're really at eof */
-                print_progress_bar(self, i, -1, 100.0);
-                tox_file_send_control(m, friendnum, 0, filenum, TOX_FILECONTROL_FINISHED, 0, 0);
-                file_senders[i].finished = true;
-            } else {
-                char msg[MAX_STR_SIZE];
-                snprintf(msg, sizeof(msg), "File transfer for '%s' failed: Read error.", file_senders[i].filename);
-                close_file_sender(self, m, i, msg, TOX_FILECONTROL_KILL, filenum, friendnum);
-                sound_notify(self, error, NT_NOFOCUS | NT_WNDALERT_2, NULL);
-
-                if (self->active_box != -1)
-                    box_notify2(self, error, NT_NOFOCUS | NT_WNDALERT_2, self->active_box, "%s", msg);
-                else
-                    box_notify(self, error, NT_NOFOCUS | NT_WNDALERT_2, &self->active_box, self->name, "%s", msg);
-            }
-
-            return;
-        }
-    }
-}
-
-void do_file_senders(Tox *m)
-{
-    int i;
-
-    for (i = 0; i < max_file_senders_index; ++i) {
-        if (!file_senders[i].active)
-            continue;
-
-        if (file_senders[i].queue_pos > 0) {
-            --file_senders[i].queue_pos;
-            continue;
-        }
-
-        ToxWindow *self = file_senders[i].toxwin;
-        char *filename = file_senders[i].filename;
-        int filenum = file_senders[i].filenum;
-        uint32_t friendnum = file_senders[i].friendnum;
-
-        /* kill file transfer if chatwindow is closed */
-        if (self->chatwin == NULL) {
-            close_file_sender(self, m, i, NULL, TOX_FILECONTROL_KILL, filenum, friendnum);
-            continue;
-        }
-
-        /* If file transfer has timed out kill transfer and send kill control */
-        if (timed_out(file_senders[i].timestamp, get_unix_time(), TIMEOUT_FILESENDER)
-            && (!file_senders[i].paused || (file_senders[i].paused && file_senders[i].noconnection))) {
-            char msg[MAX_STR_SIZE];
-            snprintf(msg, sizeof(msg), "File transfer for '%s' timed out.", filename);
-            close_file_sender(self, m, i, msg, TOX_FILECONTROL_KILL, filenum, friendnum);
-
-            if (self->active_box != -1)
-                box_notify2(self, error, NT_NOFOCUS | NT_WNDALERT_2, self->active_box, "%s", msg);
-            else
-                box_notify(self, error, NT_NOFOCUS | NT_WNDALERT_2, &self->active_box, self->name, "%s", msg);
-
-            continue;
-        }
-
-        if ( !(file_senders[i].paused | file_senders[i].noconnection | file_senders[i].finished) )
-            send_file_data(self, m, i, friendnum, filenum, filename);
-
-        file_senders[i].queue_pos = num_active_file_senders - 1;
-    }
-
-    refresh_sender_prog(m);
-    refresh_recv_prog(m);
-}

src/file_senders.h

@@ -1,76 +0,0 @@
-/*  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 KiB 1024
-#define MiB 1048576       /* 1024 ^ 2 */
-#define GiB 1073741824    /* 1024 ^ 3 */
-
-#define FILE_PIECE_SIZE 2048    /* must be >= (MAX_CRYPTO_DATA_SIZE - 2) in toxcore/net_crypto.h */
-#define MAX_FILES 32
-#define TIMEOUT_FILESENDER 120
-
-typedef struct {
-    FILE *file;
-    ToxWindow *toxwin;
-    uint32_t friendnum;
-    bool active;
-    bool noconnection;  /* set when the connection has been interrupted */
-    bool paused;        /* set when transfer has been explicitly paused */
-    bool finished;      /* set after entire file has been sent but no TOX_FILECONTROL_FINISHED receieved */
-    bool started;       /* set after TOX_FILECONTROL_ACCEPT received */
-    int filenum;
-    char nextpiece[FILE_PIECE_SIZE];
-    size_t piecelen;
-    char filename[MAX_STR_SIZE];
-    uint64_t timestamp;    /* marks the last time data was successfully transfered */
-    uint64_t last_progress;    /* marks the last time the progress bar was refreshed */
-    double bps;
-    uint64_t size;
-    uint32_t line_id;
-    uint8_t queue_pos;
-} FileSender;
-
-/* creates initial progress line that will be updated during file transfer.
-   Assumes progline is of size MAX_STR_SIZE */
-void prep_prog_line(char *progline);
-
-/* prints a progress bar for file transfers.
-   if friendnum is -1 we're sending the file, otherwise we're receiving.  */
-void print_progress_bar(ToxWindow *self, int idx, int friendnum, double pct_remain);
-
-/* set CTRL to -1 if we don't want to send a control signal.
-   set msg to NULL if we don't want to display a message */
-void close_file_sender(ToxWindow *self, Tox *m, int i, const char *msg, int CTRL, int filenum, int32_t friendnum);
-
-/* called whenever a file sender is opened or closed */
-void reset_file_sender_queue(void);
-
-void close_all_file_senders(Tox *m);
-void do_file_senders(Tox *m);
-
-#endif  /* #define FILESENDERS_H */

src/file_transfers.c

@@ -35,148 +35,226 @@
 
 extern FriendsList Friends;
 
-#define NUM_PROG_MARKS 50    /* number of "#"'s in file transfer progress bar. Keep well below MAX_STR_SIZE */
+/* number of "#"'s in file transfer progress bar. Keep well below MAX_STR_SIZE */
+#define NUM_PROG_MARKS 50
 
 /* creates initial progress line that will be updated during file transfer.
-   Assumes progline is of size MAX_STR_SIZE */
-void prep_prog_line(char *progline)
+   Assumes progline has room for at least MAX_STR_SIZE bytes */
+void init_progress_bar(char *progline)
 {
-    strcpy(progline, "0.0 B/s [");
+    strcpy(progline, "0% [");
     int i;
 
     for (i = 0; i < NUM_PROG_MARKS; ++i)
         strcat(progline, "-");
 
-    strcat(progline, "] 0%");
+    strcat(progline, "] 0.0 B/s");
 }
 
-/* prints a progress bar for file transfers.
-   if friendnum is -1 we're sending the file, otherwise we're receiving.  */
+/* prints a progress bar for file transfers. */
 void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t line_id)
 {
-    char msg[MAX_STR_SIZE];
-    bytes_convert_str(msg, sizeof(msg), bps);
-    strcat(msg, "/s [");
+    if (bps < 0 || pct_done < 0 || pct_done > 100)
+        return;
 
+    char pct_str[24];
+    snprintf(pct_str, sizeof(pct_str), "%.1f%%", pct_done);
+
+    char bps_str[24];
+    bytes_convert_str(bps_str, sizeof(bps_str), bps);
+
+    char prog_line[NUM_PROG_MARKS + 1] = {0};
     int n = pct_done / (100 / NUM_PROG_MARKS);
     int i, j;
 
     for (i = 0; i < n; ++i)
-        strcat(msg, "#");
+        strcat(prog_line, "=");
 
-    for (j = i; j < NUM_PROG_MARKS; ++j)
-        strcat(msg, "-");
+    if (pct_done < 100)
+        strcpy(prog_line + n, ">");
 
-    strcat(msg, "] ");
+    for (j = i; j < NUM_PROG_MARKS - 1; ++j)
+        strcat(prog_line, "-");
 
-    char pctstr[16];
-    const char *frmt = pct_done == 100 ? "%.f%%" : "%.1f%%";
-    snprintf(pctstr, sizeof(pctstr), frmt, pct_done);
-    strcat(msg, pctstr);
+    char full_line[strlen(pct_str) + NUM_PROG_MARKS + strlen(bps_str) + 7];
+    snprintf(full_line, sizeof(full_line), "%s [%s] %s/s", pct_str, prog_line, bps_str);
 
-    line_info_set(self, line_id, msg);
+    line_info_set(self, line_id, full_line);
 }
 
-/* Filenumbers >= this number are receiving, otherwise sending.
- * Warning: This behaviour is not defined by the Tox API and is subject to change at any time.
- */
-#define FILE_NUMBER_MAGIC_NUM (1 << 16)
-
-/* Returns filenum's file transfer array index */
-uint32_t get_file_transfer_index(uint32_t filenum)
+static void refresh_progress_helper(ToxWindow *self, Tox *m, struct FileTransfer *ft)
 {
-    return filenum >= FILE_NUMBER_MAGIC_NUM ? (filenum >> 16) - 1 : filenum;
+    if (ft->state == FILE_TRANSFER_INACTIVE)
+        return;
+
+    /* Timeout must be set to 1 second to show correct bytes per second */
+    if (!timed_out(ft->last_line_progress, 1))
+        return;
+
+    double remain = ft->file_size - ft->position;
+    double pct_done = remain > 0 ? (1 - (remain / ft->file_size)) * 100 : 100;
+    print_progress_bar(self, ft->bps, pct_done, ft->line_id);
+
+    ft->bps = 0;
+    ft->last_line_progress = get_unix_time();
 }
 
-/* Returns the filenumber of a file receiver's index */
-uint32_t get_file_receiver_filenum(uint32_t idx)
-{
-    return (idx + 1) << 16;
-}
-
-/* Return true if filenum is associated with a file receiver, false if file sender */
-bool filenum_is_sending(uint32_t filenum)
-{
-    return filenum < FILE_NUMBER_MAGIC_NUM;
-}
-
-/* refreshes active file receiver status bars for friendnum */
+/* refreshes active file transfer status bars. */
 void refresh_file_transfer_progress(ToxWindow *self, Tox *m, uint32_t friendnum)
 {
-    uint64_t curtime = get_unix_time();
     size_t i;
 
     for (i = 0; i < MAX_FILES; ++i) {
-        if (Friends.list[friendnum].file_receiver[i].active) {
-            if (timed_out(Friends.list[friendnum].file_receiver[i].last_progress, curtime, 1)) {
-                uint64_t size = Friends.list[friendnum].file_receiver[i].file_size;
-                double remain = size - Friends.list[friendnum].file_receiver[i].position;
-                double pct_done = remain > 0 ? (1 - (remain / size)) * 100 : 100;
-
-                print_progress_bar(self, Friends.list[friendnum].file_receiver[i].bps, pct_done,
-                                   Friends.list[friendnum].file_receiver[i].line_id);
-
-                Friends.list[friendnum].file_receiver[i].bps = 0;
-                Friends.list[friendnum].file_receiver[i].last_progress = curtime;
-            }
-        }
-
-        if (Friends.list[friendnum].file_sender[i].active) {
-            if (timed_out(Friends.list[friendnum].file_sender[i].last_progress, curtime, 1)) {
-                uint64_t size = Friends.list[friendnum].file_sender[i].file_size;
-                double remain = size - Friends.list[friendnum].file_sender[i].position;
-                double pct_done = remain > 0 ? (1 - (remain / size)) * 100 : 100;
-
-                print_progress_bar(self, Friends.list[friendnum].file_sender[i].bps, pct_done,
-                                   Friends.list[friendnum].file_sender[i].line_id);
-
-                Friends.list[friendnum].file_sender[i].bps = 0;
-                Friends.list[friendnum].file_sender[i].last_progress = curtime;
-            }
-        }
+        refresh_progress_helper(self, m, &Friends.list[friendnum].file_receiver[i]);
+        refresh_progress_helper(self, m, &Friends.list[friendnum].file_sender[i]);
     }
 }
 
-/* Closes file transfer with filenum.
+/* Returns a pointer to friendnum's FileTransfer struct associated with filenum.
+ * Returns NULL if filenum is invalid.
+ */
+struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filenum)
+{
+    size_t i;
+
+    for (i = 0; i < MAX_FILES; ++i) {
+        struct FileTransfer *ft_send = &Friends.list[friendnum].file_sender[i];
+
+        if (ft_send->state != FILE_TRANSFER_INACTIVE && ft_send->filenum == filenum)
+            return ft_send;
+
+        struct FileTransfer *ft_recv = &Friends.list[friendnum].file_receiver[i];
+
+        if (ft_recv->state != FILE_TRANSFER_INACTIVE && ft_recv->filenum == filenum)
+            return ft_recv;
+    }
+
+    return NULL;
+}
+
+/* Returns a pointer to the FileTransfer struct associated with index with the direction specified.
+ * Returns NULL on failure.
+ */
+struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t index,
+        FILE_TRANSFER_DIRECTION direction)
+{
+    if (direction != FILE_TRANSFER_RECV && direction != FILE_TRANSFER_SEND)
+        return NULL;
+
+    size_t i;
+
+    for (i = 0; i < MAX_FILES; ++i) {
+        struct FileTransfer *ft = direction == FILE_TRANSFER_SEND ?
+                                      &Friends.list[friendnum].file_sender[i] :
+                                      &Friends.list[friendnum].file_receiver[i];
+
+        if (ft->state != FILE_TRANSFER_INACTIVE && ft->index == index)
+            return ft;
+    }
+
+    return NULL;
+}
+
+/* Returns a pointer to an unused file sender.
+ * Returns NULL if all file senders are in use.
+ */
+static struct FileTransfer *new_file_sender(ToxWindow *window, uint32_t friendnum, uint32_t filenum, uint8_t type)
+{
+    size_t i;
+
+    for (i = 0; i < MAX_FILES; ++i) {
+        struct FileTransfer *ft = &Friends.list[friendnum].file_sender[i];
+
+        if (ft->state == FILE_TRANSFER_INACTIVE) {
+            memset(ft, 0, sizeof(struct FileTransfer));
+            ft->window = window;
+            ft->index = i;
+            ft->friendnum = friendnum;
+            ft->filenum = filenum;
+            ft->file_type = type;
+            ft->last_keep_alive = get_unix_time();
+            ft->state = FILE_TRANSFER_PENDING;
+            ft->direction = FILE_TRANSFER_SEND;
+            return ft;
+        }
+    }
+
+    return NULL;
+}
+
+/* Returns a pointer to an unused file receiver.
+ * Returns NULL if all file receivers are in use.
+ */
+static struct FileTransfer *new_file_receiver(ToxWindow *window, uint32_t friendnum, uint32_t filenum, uint8_t type)
+{
+    size_t i;
+
+    for (i = 0; i < MAX_FILES; ++i) {
+        struct FileTransfer *ft = &Friends.list[friendnum].file_receiver[i];
+
+        if (ft->state == FILE_TRANSFER_INACTIVE) {
+            memset(ft, 0, sizeof(struct FileTransfer));
+            ft->window = window;
+            ft->index = i;
+            ft->friendnum = friendnum;
+            ft->filenum = filenum;
+            ft->file_type = type;
+            ft->last_keep_alive = get_unix_time();
+            ft->state = FILE_TRANSFER_PENDING;
+            ft->direction = FILE_TRANSFER_RECV;
+            return ft;
+        }
+    }
+
+    return NULL;
+}
+
+/* Initializes an unused file transfer and returns its pointer.
+ * Returns NULL on failure.
+ */
+struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnum, uint32_t filenum,
+                                       FILE_TRANSFER_DIRECTION direction, uint8_t type)
+{
+    if (direction == FILE_TRANSFER_RECV)
+        return new_file_receiver(window, friendnum, filenum, type);
+
+    if (direction == FILE_TRANSFER_SEND)
+        return new_file_sender(window, friendnum, filenum, type);
+
+    return NULL;
+}
+
+
+/* Closes file transfer ft.
+ *
  * Set CTRL to -1 if we don't want to send a control signal.
  * Set message or self to NULL if we don't want to display a message.
  */
-void close_file_transfer(ToxWindow *self, Tox *m, uint32_t filenum, uint32_t friendnum, int CTRL,
-                        const char *message, Notification sound_type)
+void close_file_transfer(ToxWindow *self, Tox *m, struct FileTransfer *ft, int CTRL, const char *message,
+                         Notification sound_type)
 {
-    uint32_t idx = get_file_transfer_index(filenum);
-    bool sending = filenum_is_sending(filenum);
-
-    if (sending && Friends.list[friendnum].file_sender[idx].active) {
-        FILE *fp = Friends.list[friendnum].file_sender[idx].file;
-
-        if (fp)
-            fclose(fp);
-
-        memset(&Friends.list[friendnum].file_sender[idx], 0, sizeof(struct FileSender));
-    }
-    else if (!sending && Friends.list[friendnum].file_receiver[idx].active) {
-        FILE *fp = Friends.list[friendnum].file_receiver[idx].file;
-
-        if (fp)
-            fclose(fp);
-
-        memset(&Friends.list[friendnum].file_receiver[idx], 0, sizeof(struct FileReceiver));
-    }
-    else
+    if (!ft)
         return;
 
+    if (ft->state == FILE_TRANSFER_INACTIVE)
+        return;
+
+    if (ft->file)
+        fclose(ft->file);
+
     if (CTRL >= 0)
-        tox_file_control(m, friendnum, filenum, CTRL, NULL);
+        tox_file_control(m, ft->friendnum, ft->filenum, (TOX_FILE_CONTROL) CTRL, NULL);
 
     if (message && self) {
-        if (self->active_box != -1)
+        if (self->active_box != -1 && sound_type != silent)
             box_notify2(self, sound_type, NT_NOFOCUS | NT_WNDALERT_2, self->active_box, "%s", message);
         else
             box_notify(self, sound_type, NT_NOFOCUS | NT_WNDALERT_2, &self->active_box, self->name, "%s", message);
 
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", message);
     }
+
+    memset(ft, 0, sizeof(struct FileTransfer));
 }
 
 /* Kills all active file transfers for friendnum */
@@ -185,10 +263,15 @@ void kill_all_file_transfers_friend(Tox *m, uint32_t friendnum)
     size_t i;
 
     for (i = 0; i < MAX_FILES; ++i) {
-        fprintf(stderr, "%lu\n", i);
-        if (Friends.list[friendnum].file_sender[i].active)
-            close_file_transfer(NULL, m, i, friendnum, -1, NULL, silent);
-        if (Friends.list[friendnum].file_receiver[i].active)
-            close_file_transfer(NULL, m, get_file_receiver_filenum(i), friendnum, -1, NULL, silent);
+        close_file_transfer(NULL, m, &Friends.list[friendnum].file_sender[i], TOX_FILE_CONTROL_CANCEL, NULL, silent);
+        close_file_transfer(NULL, m, &Friends.list[friendnum].file_receiver[i], TOX_FILE_CONTROL_CANCEL, NULL, silent);
     }
 }
+
+void kill_all_file_transfers(Tox *m)
+{
+    size_t i;
+
+    for (i = 0; i < Friends.max_idx; ++i)
+        kill_all_file_transfers_friend(m, Friends.list[i].num);
+}

src/file_transfers.h

@@ -30,67 +30,82 @@
 #include "notify.h"
 
 #define KiB 1024
-#define MiB 1048576       /* 1024 ^ 2 */
-#define GiB 1073741824    /* 1024 ^ 3 */
+#define MiB 1048576       /* 1024^2 */
+#define GiB 1073741824    /* 1024^3 */
 
-#define FILE_PIECE_SIZE 2048
 #define MAX_FILES 32
-#define TIMEOUT_FILESENDER 120
 
-struct FileSender {
-    FILE *file;
-    char file_name[TOX_MAX_FILENAME_LENGTH];
-    bool active;
-    bool noconnection;  /* set when the connection has been interrupted */
-    bool paused;        /* set when transfer has been explicitly paused */
-    bool started;       /* set after TOX_FILECONTROL_ACCEPT received */
-    uint64_t timestamp;        /* marks the last time data was successfully transfered */
-    double bps;
-    uint64_t file_size;
-    uint64_t last_progress;    /* marks the last time the progress bar was refreshed */
-    uint64_t position;
-    uint32_t line_id;
-};
+typedef enum FILE_TRANSFER_STATE {
+    FILE_TRANSFER_INACTIVE,
+    FILE_TRANSFER_PAUSED,
+    FILE_TRANSFER_PENDING,
+    FILE_TRANSFER_STARTED,
+} FILE_TRANSFER_STATE;
 
-struct FileReceiver {
+typedef enum FILE_TRANSFER_DIRECTION {
+    FILE_TRANSFER_SEND,
+    FILE_TRANSFER_RECV
+} FILE_TRANSFER_DIRECTION;
+
+struct FileTransfer {
+    ToxWindow *window;
     FILE *file;
-    char file_path[PATH_MAX + 1];
-    bool pending;
-    bool active;
-    double bps;
+    FILE_TRANSFER_STATE state;
+    FILE_TRANSFER_DIRECTION direction;
+    uint8_t file_type;
+    char file_name[TOX_MAX_FILENAME_LENGTH + 1];
+    char file_path[PATH_MAX + 1];    /* Not used by senders */
+    double   bps;
+    uint32_t filenum;
+    uint32_t friendnum;
+    size_t   index;
     uint64_t file_size;
-    uint64_t last_progress;
     uint64_t position;
+    time_t   last_line_progress;   /* The last time we updated the progress bar */
+    time_t   last_keep_alive;  /* The last time we sent or received data */
     uint32_t line_id;
+    uint8_t  file_id[TOX_FILE_ID_LENGTH];
 };
 
 /* creates initial progress line that will be updated during file transfer.
    progline must be at lesat MAX_STR_SIZE bytes */
-void prep_prog_line(char *progline);
+void init_progress_bar(char *progline);
 
 /* prints a progress bar for file transfers */
 void print_progress_bar(ToxWindow *self, double pct_done, double bps, uint32_t line_id);
 
-/* refreshes active file receiver status bars for friendnum */
+/* refreshes active file transfer status bars. */
 void refresh_file_transfer_progress(ToxWindow *self, Tox *m, uint32_t friendnum);
 
-/* Returns filenum's file transfer array index */
-uint32_t get_file_transfer_index(uint32_t filenum);
+/* Returns a pointer to friendnum's FileTransfer struct associated with filenum.
+ * Returns NULL if filenum is invalid.
+ */
+struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filenum);
 
-/* Returns the filenumber of a file receiver's index */
-uint32_t get_file_receiver_filenum(uint32_t idx);
 
-/* Return true if filenum is associated with a file receiver, false if file sender */
-bool filenum_is_sending(uint32_t filenum);
+/* Returns a pointer to the FileTransfer struct associated with index with the direction specified.
+ * Returns NULL on failure.
+ */
+struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t index,
+        FILE_TRANSFER_DIRECTION direction);
 
-/* Closes file transfer with filenum.
+/* Initializes an unused file transfer and returns its pointer.
+ * Returns NULL on failure.
+ */
+struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnum, uint32_t filenum,
+                                       FILE_TRANSFER_DIRECTION direction, uint8_t type);
+
+/* Closes file transfer ft.
+ *
  * Set CTRL to -1 if we don't want to send a control signal.
  * Set message or self to NULL if we don't want to display a message.
  */
-void close_file_transfer(ToxWindow *self, Tox *m, uint32_t filenum, uint32_t friendnum, int CTRL,
-                         const char *message, Notification sound_type);
+void close_file_transfer(ToxWindow *self, Tox *m, struct FileTransfer *ft, int CTRL, const char *message,
+                         Notification sound_type);
 
 /* Kills all active file transfers for friendnum */
 void kill_all_file_transfers_friend(Tox *m, uint32_t friendnum);
 
+void kill_all_file_transfers(Tox *m);
+
 #endif  /* #define FILE_TRANSFERS_H */

src/friendlist.c

@@ -25,6 +25,7 @@
 #include <stdlib.h>
 #include <time.h>
 #include <arpa/inet.h>
+#include <assert.h>
 
 #include <tox/tox.h>
 
@@ -38,6 +39,7 @@
 #include "notify.h"
 #include "help.h"
 #include "log.h"
+#include "avatars.h"
 
 #ifdef AUDIO
 #include "audio_call.h"
@@ -122,30 +124,43 @@ void kill_friendlist(void)
     realloc_friends(0);
 }
 
+/* Saves the blocklist to path. If there are no items in the blocklist the
+ * empty file will be removed.
+ *
+ * Returns 0 if stored successfully.
+ * Returns -1 on failure.
+ */
+#define TEMP_BLOCKLIST_EXT ".tmp"
 static int save_blocklist(char *path)
 {
-    if (path == NULL)
+    if (path == NULL) {
         return -1;
+    }
 
     int len = sizeof(BlockedFriend) * Blocked.num_blocked;
-    char *data = malloc(len);
+    char *data = malloc(len * sizeof(char));
 
-    if (data == NULL)
-        exit_toxic_err("Failed in save_blocklist", FATALERR_MEMORY);
+    if (data == NULL) {
+        return -1;
+    }
 
-    int i;
-
-    int count = 0;
+    int i, count = 0;
 
     for (i = 0; i < Blocked.max_idx; ++i) {
-        if (count > Blocked.num_blocked)
-            goto on_error;
+        if (count > Blocked.num_blocked) {
+            free(data);
+            return -1;
+        }
 
         if (Blocked.list[i].active) {
+            if (Blocked.list[i].namelength > TOXIC_MAX_NAME_LENGTH) {
+                continue;
+            }
+
             BlockedFriend tmp;
             memset(&tmp, 0, sizeof(BlockedFriend));
             tmp.namelength = htons(Blocked.list[i].namelength);
-            memcpy(tmp.name, Blocked.list[i].name, Blocked.list[i].namelength + 1);
+            memcpy(tmp.name, Blocked.list[i].name, Blocked.list[i].namelength + 1);  // Include null byte
             memcpy(tmp.pub_key, Blocked.list[i].pub_key, TOX_PUBLIC_KEY_SIZE);
 
             uint8_t lastonline[sizeof(uint64_t)];
@@ -158,21 +173,42 @@ static int save_blocklist(char *path)
         }
     }
 
-    FILE *fp = fopen(path, "wb");
+    /* Blocklist is empty, we can remove the empty file */
+    if (count == 0) {
+        free(data);
 
-    if (fp == NULL)
-        goto on_error;
+        if (remove(path) != 0) {
+            return -1;
+        }
 
-    if (fwrite(data, len, 1, fp) != 1)
-        goto on_error;
+        return 0;
+    }
+
+    char temp_path[strlen(path) + strlen(TEMP_BLOCKLIST_EXT) + 1];
+    snprintf(temp_path, sizeof(temp_path), "%s%s", path, TEMP_BLOCKLIST_EXT);
+
+    FILE *fp = fopen(temp_path, "wb");
+
+    if (fp == NULL) {
+        free(data);
+        return -1;
+    }
+
+    if (fwrite(data, len, 1, fp) != 1) {
+        fprintf(stderr, "Failed to write blocklist data.\n");
+        fclose(fp);
+        free(data);
+        return -1;
+    }
 
     fclose(fp);
     free(data);
-    return 0;
 
-on_error:
-    free(data);
-    return -1;
+    if (rename(temp_path, path) != 0) {
+        return -1;
+    }
+
+    return 0;
 }
 
 static void sort_blocklist_index(void);
@@ -194,22 +230,15 @@ int load_blocklist(char *path)
         return -1;
     }
 
-    char *data = malloc(len);
-
-    if (data == NULL) {
-        fclose(fp);
-        exit_toxic_err("Failed in load_blocklist", FATALERR_MEMORY);
-    }
+    char data[len];
 
     if (fread(data, len, 1, fp) != 1) {
         fclose(fp);
-        free(data);
         return -1;
     }
 
     if (len % sizeof(BlockedFriend) != 0) {
         fclose(fp);
-        free(data);
         return -1;
     }
 
@@ -220,14 +249,20 @@ int load_blocklist(char *path)
     int i;
 
     for (i = 0; i < num; ++i) {
+        BlockedFriend tmp;
+        memset(&tmp, 0, sizeof(BlockedFriend));
         memset(&Blocked.list[i], 0, sizeof(BlockedFriend));
 
-        BlockedFriend tmp;
         memcpy(&tmp, data + i * sizeof(BlockedFriend), sizeof(BlockedFriend));
+        Blocked.list[i].namelength = ntohs(tmp.namelength);
+
+        if (Blocked.list[i].namelength > TOXIC_MAX_NAME_LENGTH) {
+            continue;
+        }
+
         Blocked.list[i].active = true;
         Blocked.list[i].num = i;
-        Blocked.list[i].namelength = ntohs(tmp.namelength);
-        memcpy(Blocked.list[i].name, tmp.name, Blocked.list[i].namelength + 1);
+        memcpy(Blocked.list[i].name, tmp.name, Blocked.list[i].namelength + 1);   // copy null byte
         memcpy(Blocked.list[i].pub_key, tmp.pub_key, TOX_PUBLIC_KEY_SIZE);
 
         uint8_t lastonline[sizeof(uint64_t)];
@@ -238,7 +273,6 @@ int load_blocklist(char *path)
         ++Blocked.num_blocked;
     }
 
-    free(data);
     fclose(fp);
     sort_blocklist_index();
 
@@ -289,10 +323,10 @@ static void sort_blocklist_index(void)
     qsort(Blocked.index, Blocked.num_blocked, sizeof(uint32_t), index_name_cmp_block);
 }
 
-static void update_friend_last_online(uint32_t num, uint64_t timestamp)
+static void update_friend_last_online(uint32_t num, time_t timestamp)
 {
     Friends.list[num].last_online.last_on = timestamp;
-    Friends.list[num].last_online.tm = *localtime((const time_t*)&timestamp);
+    Friends.list[num].last_online.tm = *localtime((const time_t *)&timestamp);
 
     /* if the format changes make sure TIME_STR_SIZE is the correct size */
     const char *t = user_settings->timestamp_format;
@@ -330,11 +364,15 @@ static void friendlist_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num,
     if (num >= Friends.max_idx)
         return;
 
-    if (connection_status == TOX_CONNECTION_NONE)
+    if (connection_status == TOX_CONNECTION_NONE) {
         --Friends.num_online;
-    else
+    } else if (Friends.list[num].connection_status == TOX_CONNECTION_NONE) {
         ++Friends.num_online;
 
+        if (avatar_send(m, num) == -1)
+            fprintf(stderr, "avatar_send failed for friend %d\n", num);
+    }
+
     Friends.list[num].connection_status = connection_status;
     update_friend_last_online(num, get_unix_time());
     store_data(m, DATA_FILE);
@@ -403,13 +441,19 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
         Friends.list[i].status = TOX_USER_STATUS_NONE;
         Friends.list[i].logging_on = (bool) user_settings->autolog == AUTOLOG_ON;
 
-        TOX_ERR_FRIEND_GET_PUBLIC_KEY err;
-        tox_friend_get_public_key(m, num, (uint8_t *) Friends.list[i].pub_key, &err);
+        TOX_ERR_FRIEND_GET_PUBLIC_KEY pkerr;
+        tox_friend_get_public_key(m, num, (uint8_t *) Friends.list[i].pub_key, &pkerr);
 
-        if (err != TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK)
-            fprintf(stderr, "tox_friend_get_public_key failed (error %d)\n", err);
+        if (pkerr != TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK)
+            fprintf(stderr, "tox_friend_get_public_key failed (error %d)\n", pkerr);
 
-        // update_friend_last_online(i, 0);
+        TOX_ERR_FRIEND_GET_LAST_ONLINE loerr;
+        time_t t = tox_friend_get_last_online(m, num, &loerr);
+
+        if (loerr != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK)
+            t = 0;
+
+        update_friend_last_online(i, t);
 
         char tempname[TOX_MAX_NAME_LENGTH] = {0};
         get_nick_truncate(m, tempname, num);
@@ -460,7 +504,7 @@ static void friendlist_add_blocked(Tox *m, uint32_t fnum, uint32_t bnum)
     }
 }
 
-static void friendlist_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum, uint32_t kind,
+static void friendlist_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum,
                                   uint64_t file_size, const char *filename, size_t name_length)
 {
     if (num >= Friends.max_idx)
@@ -503,7 +547,7 @@ static void friendlist_onGroupInvite(ToxWindow *self, Tox *m, int32_t num, uint8
     get_nick_truncate(m, nick, num);
 
     line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, RED,
-                 "* Group chat invite from %s failed: too many windows are open.", nick);
+                  "* Group chat invite from %s failed: too many windows are open.", nick);
 
     sound_notify(prompt, notif_error, NT_WNDALERT_1, NULL);
 }
@@ -525,6 +569,7 @@ static void select_friend(ToxWindow *self, wint_t key, int *selected, int num)
 static void delete_friend(Tox *m, uint32_t f_num)
 {
     TOX_ERR_FRIEND_DELETE err;
+
     if (tox_friend_delete(m, f_num, &err) != true) {
         fprintf(stderr, "tox_friend_delete failed with error %d\n", err);
         return;
@@ -609,15 +654,19 @@ static void draw_del_popup(void)
     wprintw(PendingDelete.popup, "Delete contact ");
     wattron(PendingDelete.popup, A_BOLD);
 
+    pthread_mutex_lock(&Winthread.lock);
+
     if (blocklist_view == 0)
         wprintw(PendingDelete.popup, "%s", Friends.list[PendingDelete.num].name);
     else
         wprintw(PendingDelete.popup, "%s", Blocked.list[PendingDelete.num].name);
 
+    pthread_mutex_unlock(&Winthread.lock);
+
     wattroff(PendingDelete.popup, A_BOLD);
     wprintw(PendingDelete.popup, "? y/n");
 
-    wrefresh(PendingDelete.popup);
+    wnoutrefresh(PendingDelete.popup);
 }
 
 /* deletes contact from blocked list */
@@ -687,7 +736,7 @@ static void unblock_friend(Tox *m, uint32_t bnum)
     uint32_t friendnum = tox_friend_add_norequest(m, (uint8_t *) Blocked.list[bnum].pub_key, &err);
 
     if (err != TOX_ERR_FRIEND_ADD_OK) {
-        line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to unblock friend (error %d)\n", err);
+        line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to unblock friend (error %d)", err);
         return;
     }
 
@@ -735,7 +784,7 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
         return;
 
     switch (key) {
-        case '\n':
+        case '\r':
             if (blocklist_view)
                 break;
 
@@ -762,6 +811,7 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
                 block_friend(m, f);
             else
                 unblock_friend(m, f);
+
             break;
 
         case KEY_RIGHT:
@@ -774,6 +824,7 @@ static void friendlist_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
                 select_friend(self, key, &Friends.num_selected, Friends.num_friends);
             else
                 select_friend(self, key, &Blocked.num_selected, Blocked.num_blocked);
+
             break;
     }
 }
@@ -844,7 +895,7 @@ static void blocklist_onDraw(ToxWindow *self, Tox *m, int y2, int x2)
             wprintw(self->window, "%02X", Blocked.list[selected_num].pub_key[i] & 0xff);
     }
 
-    wrefresh(self->window);
+    wnoutrefresh(self->window);
     draw_del_popup();
 
     if (self->help->active)
@@ -873,12 +924,13 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
         return;
     }
 
-   // uint64_t cur_time = get_unix_time();
-   // struct tm cur_loc_tm = *localtime((const time_t *) &cur_time);
+    time_t cur_time = get_unix_time();
+    struct tm cur_loc_tm = *localtime((const time_t *) &cur_time);
 
     wattron(self->window, A_BOLD);
     wprintw(self->window, " Online: ");
     wattroff(self->window, A_BOLD);
+
     wprintw(self->window, "%d/%d \n\n", Friends.num_online, Friends.num_friends);
 
     if ((y2 - FLIST_OFST) <= 0)
@@ -887,18 +939,30 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
     uint32_t selected_num = 0;
 
     /* Determine which portion of friendlist to draw based on current position */
+    pthread_mutex_lock(&Winthread.lock);
     int page = Friends.num_selected / (y2 - FLIST_OFST);
+    pthread_mutex_unlock(&Winthread.lock);
+
     int start = (y2 - FLIST_OFST) * page;
     int end = y2 - FLIST_OFST + start;
 
+    pthread_mutex_lock(&Winthread.lock);
+    size_t num_friends = Friends.num_friends;
+    pthread_mutex_unlock(&Winthread.lock);
+
     int i;
 
-    for (i = start; i < Friends.num_friends && i < end; ++i) {
+    for (i = start; i < num_friends && i < end; ++i) {
+        pthread_mutex_lock(&Winthread.lock);
         uint32_t f = Friends.index[i];
+        bool is_active = Friends.list[f].active;
+        int num_selected = Friends.num_selected;
+        pthread_mutex_unlock(&Winthread.lock);
+
         bool f_selected = false;
 
-        if (Friends.list[f].active) {
-            if (i == Friends.num_selected) {
+        if (is_active) {
+            if (i == num_selected) {
                 wattron(self->window, A_BOLD);
                 wprintw(self->window, " > ");
                 wattroff(self->window, A_BOLD);
@@ -908,17 +972,23 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                 wprintw(self->window, "   ");
             }
 
-            if (Friends.list[f].connection_status != TOX_CONNECTION_NONE) {
-                TOX_USER_STATUS status = Friends.list[f].status;
+            pthread_mutex_lock(&Winthread.lock);
+            TOX_CONNECTION connection_status = Friends.list[f].connection_status;
+            TOX_USER_STATUS status = Friends.list[f].status;
+            pthread_mutex_unlock(&Winthread.lock);
+
+            if (connection_status != TOX_CONNECTION_NONE) {
                 int colour = MAGENTA;
 
                 switch (status) {
                     case TOX_USER_STATUS_NONE:
                         colour = GREEN;
                         break;
+
                     case TOX_USER_STATUS_AWAY:
                         colour = YELLOW;
                         break;
+
                     case TOX_USER_STATUS_BUSY:
                         colour = RED;
                         break;
@@ -932,7 +1002,9 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                     wattron(self->window, COLOR_PAIR(BLUE));
 
                 wattron(self->window, A_BOLD);
+                pthread_mutex_lock(&Winthread.lock);
                 wprintw(self->window, "%s", Friends.list[f].name);
+                pthread_mutex_unlock(&Winthread.lock);
                 wattroff(self->window, A_BOLD);
 
                 if (f_selected)
@@ -947,14 +1019,21 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                     size_t s_len = tox_friend_get_status_message_size(m, Friends.list[f].num, NULL);
                     pthread_mutex_unlock(&Winthread.lock);
 
+                    statusmsg[s_len] = '\0';
+
                     filter_str(statusmsg, s_len);
+
+                    pthread_mutex_lock(&Winthread.lock);
                     snprintf(Friends.list[f].statusmsg, sizeof(Friends.list[f].statusmsg), "%s", statusmsg);
                     Friends.list[f].statusmsg_len = strlen(Friends.list[f].statusmsg);
+                    pthread_mutex_unlock(&Winthread.lock);
                 }
 
                 /* Truncate note if it doesn't fit on one line */
                 size_t maxlen = x2 - getcurx(self->window) - 2;
 
+                pthread_mutex_lock(&Winthread.lock);
+
                 if (Friends.list[f].statusmsg_len > maxlen) {
                     Friends.list[f].statusmsg[maxlen - 3] = '\0';
                     strcat(Friends.list[f].statusmsg, "...");
@@ -962,9 +1041,11 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                     Friends.list[f].statusmsg_len = maxlen;
                 }
 
-                if (Friends.list[f].statusmsg[0])
+                if (Friends.list[f].statusmsg_len > 0)
                     wprintw(self->window, " %s", Friends.list[f].statusmsg);
 
+                pthread_mutex_unlock(&Winthread.lock);
+
                 wprintw(self->window, "\n");
             } else {
                 wprintw(self->window, "%s ", OFFLINE_CHAR);
@@ -973,47 +1054,52 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                     wattron(self->window, COLOR_PAIR(BLUE));
 
                 wattron(self->window, A_BOLD);
+                pthread_mutex_lock(&Winthread.lock);
                 wprintw(self->window, "%s", Friends.list[f].name);
+                pthread_mutex_unlock(&Winthread.lock);
                 wattroff(self->window, A_BOLD);
 
                 if (f_selected)
                     wattroff(self->window, COLOR_PAIR(BLUE));
 
-                wprintw(self->window, "\n");
-                /* Last online is currently broken in core */
+                pthread_mutex_lock(&Winthread.lock);
+                time_t last_seen = Friends.list[f].last_online.last_on;
+                pthread_mutex_unlock(&Winthread.lock);
 
-                // uint64_t last_seen = Friends.list[f].last_online.last_on;
-                //
-                // if (last_seen != 0) {
-                //     int day_dist = (
-                //             cur_loc_tm.tm_yday - Friends.list[f].last_online.tm.tm_yday
-                //         + ((cur_loc_tm.tm_year - Friends.list[f].last_online.tm.tm_year) * 365)
-                //     );
-                //     const char *hourmin = Friends.list[f].last_online.hour_min_str;
+                if (last_seen != 0) {
+                    pthread_mutex_lock(&Winthread.lock);
 
-                //     switch (day_dist) {
-                //         case 0:
-                //             wprintw(self->window, " Last seen: Today %s\n", hourmin);
-                //             break;
+                    int day_dist = (
+                                       cur_loc_tm.tm_yday - Friends.list[f].last_online.tm.tm_yday
+                                       + ((cur_loc_tm.tm_year - Friends.list[f].last_online.tm.tm_year) * 365)
+                                   );
+                    const char *hourmin = Friends.list[f].last_online.hour_min_str;
 
-                //         case 1:
-                //             wprintw(self->window, " Last seen: Yesterday %s\n", hourmin);
-                //             break;
+                    pthread_mutex_unlock(&Winthread.lock);
 
-                //         default:
-                //             wprintw(self->window, " Last seen: %d days ago\n", day_dist);
-                //             break;
-                //     }
-                // } else {
-                //     wprintw(self->window, " Last seen: Never\n");
-                // }
+                    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;
 
-    if (Friends.num_friends) {
+    if (num_friends) {
         wmove(self->window, y2 - 1, 1);
 
         wattron(self->window, A_BOLD);
@@ -1026,7 +1112,7 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
             wprintw(self->window, "%02X", Friends.list[selected_num].pub_key[i] & 0xff);
     }
 
-    wrefresh(self->window);
+    wnoutrefresh(self->window);
     draw_del_popup();
 
     if (self->help->active)
@@ -1039,23 +1125,25 @@ void disable_chatwin(uint32_t f_num)
 }
 
 #ifdef AUDIO
-static void friendlist_onAv(ToxWindow *self, ToxAv *av, int call_index)
+static void friendlist_onAV(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
-    int id = toxav_get_peer_id(av, call_index, 0);
+    assert(0);
 
-    if ( id != av_ErrorUnknown && id >= Friends.max_idx)
+    if ( friend_number >= Friends.max_idx)
         return;
 
+    assert(0);
     Tox *m = toxav_get_tox(av);
 
-    if (Friends.list[id].chatwin == -1) {
+    if (Friends.list[friend_number].chatwin == -1) {
         if (get_num_active_windows() < MAX_WINDOWS_NUM) {
-            if (toxav_get_call_state(av, call_index) == av_CallStarting) { /* Only open windows when call is incoming */
-                Friends.list[id].chatwin = add_window(m, new_chat(m, Friends.list[id].num));
+            if (state != TOXAV_FRIEND_CALL_STATE_FINISHED) {
+                Friends.list[friend_number].chatwin = add_window(m, new_chat(m, Friends.list[friend_number].num));
+                set_active_window(Friends.list[friend_number].chatwin);
             }
         } else {
             char nick[TOX_MAX_NAME_LENGTH];
-            get_nick_truncate(m, nick, Friends.list[id].num);
+            get_nick_truncate(m, nick, Friends.list[friend_number].num);
             line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Audio action from: %s!", nick);
 
             const char *errmsg = "* Warning: Too many windows are open.";
@@ -1087,22 +1175,21 @@ ToxWindow new_friendlist(void)
     ret.onGroupInvite = &friendlist_onGroupInvite;
 
 #ifdef 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.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.call_idx = -1;
+    ret.is_call = false;
     ret.device_selection[0] = ret.device_selection[1] = -1;
 #endif /* AUDIO */
 
+    ret.num = -1;
     ret.active_box = -1;
 
     Help *help = calloc(1, sizeof(Help));

src/friendlist.h

@@ -44,7 +44,7 @@ struct GroupChatInvite {
 
 typedef struct {
     char name[TOXIC_MAX_NAME_LENGTH + 1];
-    int namelength;
+    uint16_t namelength;
     char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH + 1];
     size_t statusmsg_len;
     char pub_key[TOX_PUBLIC_KEY_SIZE];
@@ -59,13 +59,13 @@ typedef struct {
     struct LastOnline last_online;
     struct GroupChatInvite group_invite;
 
-    struct FileReceiver file_receiver[MAX_FILES];
-    struct FileSender file_sender[MAX_FILES];
+    struct FileTransfer file_receiver[MAX_FILES];
+    struct FileTransfer file_sender[MAX_FILES];
 } ToxicFriend;
 
 typedef struct {
     char name[TOXIC_MAX_NAME_LENGTH + 1];
-    int namelength;
+    uint16_t namelength;
     char pub_key[TOX_PUBLIC_KEY_SIZE];
     uint32_t num;
     bool active;

src/global_commands.c

@@ -22,7 +22,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <arpa/inet.h>
 
 #include "toxic.h"
 #include "windows.h"
@@ -30,11 +29,14 @@
 #include "friendlist.h"
 #include "log.h"
 #include "line_info.h"
-#include "dns.h"
 #include "groupchat.h"
 #include "prompt.h"
 #include "help.h"
 #include "term_mplex.h"
+#include "avatars.h"
+#include "name_lookup.h"
+#include "qr_code.h"
+#include "toxic_strings.h"
 
 extern char *DATA_FILE;
 extern ToxWindow *prompt;
@@ -49,9 +51,9 @@ void cmd_accept(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
         return;
     }
 
-    int req = atoi(argv[1]);
+    long int req = strtol(argv[1], NULL, 10);
 
-    if ((req == 0 && strcmp(argv[1], "0")) || req < 0 || req > MAX_FRIEND_REQUESTS) {
+    if ((req == 0 && strcmp(argv[1], "0")) || req < 0 || req >= MAX_FRIEND_REQUESTS) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "No pending friend request with that ID.");
         return;
     }
@@ -128,6 +130,7 @@ void cmd_add_helper(ToxWindow *self, Tox *m, const char *id_bin, const char *msg
             break;
 
         case TOX_ERR_FRIEND_ADD_NULL:
+
         /* fallthrough */
         default:
             errmsg = "Faile to add friend: Unknown error.";
@@ -191,79 +194,46 @@ void cmd_add(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
         }
 
         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);
+    } else {    /* assume id is a username@domain address and do http name server lookup */
+        name_lookup(self, m, id_bin, id, msg);
     }
 }
 
 void cmd_avatar(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    // if (argc < 2) {
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set avatar: No file path supplied.");
-    //     return;
-    // }
+    if (argc < 2 || strlen(argv[1]) < 3) {
+        avatar_unset(m);
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Avatar is not set.");
+        return;
+    }
 
-    // /* turns the avatar off */
-    // if (strlen(argv[1]) < 3) {
-    //     tox_unset_avatar(m);
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "No avatar set.");
-    //     return;
-    // }
+    if (argv[1][0] != '\"') {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Path must be enclosed in quotes.");
+        return;
+    }
 
-    // if (argv[1][0] != '\"') {
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Path must be enclosed in quotes.");
-    //     return;
-    // }
+    /* remove opening and closing quotes */
+    char path[MAX_STR_SIZE];
+    snprintf(path, sizeof(path), "%s", &argv[1][1]);
+    int len = strlen(path) - 1;
 
-    // /* remove opening and closing quotes */
-    // char path[MAX_STR_SIZE];
-    // snprintf(path, sizeof(path), "%s", &argv[1][1]);
-    // int len = strlen(path) - 1;
-    // path[len] = '\0';
+    if (len <= 0) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid path.");
+        return;
+    }
 
-    // off_t sz = file_size(path);
+    path[len] = '\0';
+    char filename[MAX_STR_SIZE];
+    get_file_name(filename, sizeof(filename), path);
 
-    // if (sz <= 8) {
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set avatar: Invalid file.");
-    //     return;
-    // }
+    if (avatar_set(m, path, len) == -1) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0,
+                      "Failed to set avatar. Avatars must be in PNG format and may not exceed %d bytes.",
+                      MAX_AVATAR_FILE_SIZE);
+        return;
+    }
 
-    // FILE *fp = fopen(path, "rb");
-
-    // if (fp == NULL) {
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set avatar: Could not open file.");
-    //     return;
-    // }
-
-    // char PNG_signature[8] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};
-
-    // if (check_file_signature(PNG_signature, sizeof(PNG_signature), fp) != 0) {
-    //     fclose(fp);
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set avatar: File type not supported.");
-    //     return;
-    // }
-
-    // char *avatar = malloc(sz);
-
-    // if (avatar == NULL)
-    //     exit_toxic_err("Failed in cmd_avatar", FATALERR_MEMORY);
-
-    // if (fread(avatar, sz, 1, fp) != 1) {
-    //     fclose(fp);
-    //     free(avatar);
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set avatar: Read fail.");
-    //     return;
-    // }
-
-    // if (tox_set_avatar(m, TOX_AVATAR_FORMAT_PNG, (const uint8_t *) avatar, (uint32_t) sz) == -1)
-    //     line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set avatar");
-
-    // char filename[MAX_STR_SIZE];
-    // get_file_name(filename, sizeof(filename), path);
-    // line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Avatar set to '%s'", filename);
-
-    // fclose(fp);
-    // free(avatar);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Avatar set to '%s'", filename);
 }
 
 void cmd_clear(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@@ -280,19 +250,26 @@ void cmd_connect(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
     }
 
     const char *ip = argv[1];
-    const char *port = argv[2];
-    const char *key = argv[3];
+    const char *port_str = argv[2];
+    const char *ascii_key = argv[3];
 
-    if (atoi(port) == 0) {
+    long int port = strtol(port_str, NULL, 10);
+
+    if (port <= 0 || port > MAX_PORT_RANGE) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid port.");
         return;
     }
 
-    char *binary_string = hex_string_to_bin(key);
+    char key_binary[TOX_PUBLIC_KEY_SIZE * 2 + 1];
+
+    if (hex_string_to_bin(ascii_key, strlen(ascii_key), key_binary, TOX_PUBLIC_KEY_SIZE) == -1) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid key.");
+        return;
+    }
 
     TOX_ERR_BOOTSTRAP err;
-    tox_bootstrap(m, ip, atoi(port), (uint8_t *) binary_string, &err);
-    free(binary_string);
+    tox_bootstrap(m, ip, port, (uint8_t *) key_binary, &err);
+    tox_add_tcp_relay(m, ip, port, (uint8_t *) key_binary, &err);
 
     switch (err) {
         case TOX_ERR_BOOTSTRAP_BAD_HOST:
@@ -306,6 +283,7 @@ void cmd_connect(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
         case TOX_ERR_BOOTSTRAP_NULL:
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Bootstrap failed.");
             break;
+
         default:
             break;
     }
@@ -318,9 +296,9 @@ void cmd_decline(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
         return;
     }
 
-    int req = atoi(argv[1]);
+    long int req = strtol(argv[1], NULL, 10);
 
-    if ((req == 0 && strcmp(argv[1], "0")) || req < 0 || req > MAX_FRIEND_REQUESTS) {
+    if ((req == 0 && strcmp(argv[1], "0")) || req < 0 || req >= MAX_FRIEND_REQUESTS) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "No pending friend request with that ID.");
         return;
     }
@@ -358,31 +336,31 @@ void cmd_groupchat(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*arg
     uint8_t type;
 
     if (!strcasecmp(argv[1], "audio"))
-        type = TOX_GROUPCHAT_TYPE_AV;
+        type = TOX_CONFERENCE_TYPE_AV;
     else if (!strcasecmp(argv[1], "text"))
-        type = TOX_GROUPCHAT_TYPE_TEXT;
+        type = TOX_CONFERENCE_TYPE_TEXT;
     else {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Valid group types are: text | audio");
         return;
     }
 
-    int groupnum = -1;
+    if (type != TOX_CONFERENCE_TYPE_TEXT) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Toxic does not support audio groups.");
+        return;
+    }
 
-    if (type == TOX_GROUPCHAT_TYPE_TEXT)
-        groupnum = tox_add_groupchat(m);
-#ifdef AUDIO
-    else
-        groupnum = toxav_add_av_groupchat(m, write_device_callback_group, NULL);
-#endif
+    TOX_ERR_CONFERENCE_NEW err;
 
-    if (groupnum == -1) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Group chat instance failed to initialize.");
+    uint32_t groupnum = tox_conference_new(m, &err);
+
+    if (err != TOX_ERR_CONFERENCE_NEW_OK) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Group chat instance failed to initialize (error %d)", err);
         return;
     }
 
     if (init_groupchat_win(prompt, m, groupnum, type) == -1) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Group chat window failed to initialize.");
-        tox_del_groupchat(m, groupnum);
+        tox_conference_delete(m, groupnum, NULL);
         return;
     }
 
@@ -396,9 +374,9 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
 
     if (argc == 0) {
         if (log->log_on)
-            msg = "Logging for this window is ON. Type \"/log off\" to disable.";
+            msg = "Logging for this window is ON; type \"/log off\" to disable. (Logs are not encrypted)";
         else
-            msg = "Logging for this window is OFF. Type \"/log on\" to enable.";
+            msg = "Logging for this window is OFF; type \"/log on\" to enable.";
 
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
         return;
@@ -410,16 +388,18 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
         char myid[TOX_ADDRESS_SIZE];
         tox_self_get_address(m, (uint8_t *) myid);
 
+        int log_ret = -1;
+
         if (self->is_chat) {
             Friends.list[self->num].logging_on = true;
-            log_enable(self->name, myid, Friends.list[self->num].pub_key, log, LOG_CHAT);
+            log_ret = log_enable(self->name, myid, Friends.list[self->num].pub_key, log, LOG_CHAT);
         } else if (self->is_prompt) {
-            log_enable(self->name, myid, NULL, log, LOG_PROMPT);
+            log_ret = log_enable(self->name, myid, NULL, log, LOG_PROMPT);
         } else if (self->is_groupchat) {
-            log_enable(self->name, myid, NULL, log, LOG_GROUP);
+            log_ret = log_enable(self->name, myid, NULL, log, LOG_GROUP);
         }
 
-        msg = "Logging enabled";
+        msg = log_ret == 0 ? "Logging enabled." : "Warning: Log failed to initialize.";
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
         return;
     } else if (!strcmp(swch, "0") || !strcmp(swch, "off")) {
@@ -428,7 +408,7 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
 
         log_disable(log);
 
-        msg = "Logging disabled";
+        msg = "Logging disabled.";
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, msg);
         return;
     }
@@ -439,19 +419,74 @@ void cmd_log(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
 
 void cmd_myid(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
-    char id[TOX_ADDRESS_SIZE * 2 + 1] = {0};
-    char address[TOX_ADDRESS_SIZE];
-    tox_self_get_address(m, (uint8_t *) address);
+    char id_string[TOX_ADDRESS_SIZE * 2 + 1];
+    char bin_id[TOX_ADDRESS_SIZE];
+    tox_self_get_address(m, (uint8_t *) bin_id);
 
-    size_t i;
-
-    for (i = 0; i < TOX_ADDRESS_SIZE; ++i) {
-        char xx[3];
-        snprintf(xx, sizeof(xx), "%02X", address[i] & 0xff);
-        strcat(id, xx);
+    if (bin_id_to_string(bin_id, sizeof(bin_id), id_string, sizeof(id_string)) == -1) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to print ID.");
+        return;
     }
 
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", id);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", id_string);
+}
+
+void cmd_myqr(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    char id_string[TOX_ADDRESS_SIZE * 2 + 1];
+    char bin_id[TOX_ADDRESS_SIZE];
+    tox_self_get_address(m, (uint8_t *) bin_id);
+
+    if (bin_id_to_string(bin_id, sizeof(bin_id), id_string, sizeof(id_string)) == -1) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to create QR code.");
+        return;
+    }
+
+    char nick[TOX_MAX_NAME_LENGTH];
+    tox_self_get_name(m, (uint8_t *) nick);
+    size_t nick_len = tox_self_get_name_size(m);
+    nick[nick_len] = '\0';
+
+    size_t data_file_len = strlen(DATA_FILE);
+    char dir[data_file_len + 1];
+    size_t dir_len = get_base_dir(DATA_FILE, data_file_len, dir);
+
+#ifdef QRPNG
+
+    if (argc == 0) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Required 'txt' or 'png'");
+        return;
+    } else if (!strcmp(argv[1], "txt")) {
+
+#endif /* QRPNG */
+        char qr_path[dir_len + nick_len + strlen(QRCODE_FILENAME_EXT) + 1];
+        snprintf(qr_path, sizeof(qr_path), "%s%s%s", dir, nick, QRCODE_FILENAME_EXT);
+
+        if (ID_to_QRcode_txt(id_string, qr_path) == -1) {
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to create QR code.");
+            return;
+        }
+
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "QR code has been printed to the file '%s'", qr_path);
+
+#ifdef QRPNG
+    } else if (!strcmp(argv[1], "png")) {
+        char qr_path[dir_len + nick_len + strlen(QRCODE_FILENAME_EXT_PNG) + 1];
+        snprintf(qr_path, sizeof(qr_path), "%s%s%s", dir, nick, QRCODE_FILENAME_EXT_PNG);
+
+        if (ID_to_QRcode_png(id_string, qr_path) == -1) {
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to create QR code.");
+            return;
+        }
+
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "QR code has been printed to the file '%s'", qr_path);
+
+    } else {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Unknown option '%s' -- Required 'txt' or 'png'", argv[1]);
+        return;
+    }
+
+#endif /* QRPNG */
 }
 
 void cmd_nick(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@@ -499,15 +534,41 @@ void cmd_note(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
         return;
     }
 
-    /* remove opening and closing quotes */
+    /* remove opening and closing quotes and replace linebreaks with spaces */
     char msg[MAX_STR_SIZE];
     snprintf(msg, sizeof(msg), "%s", &argv[1][1]);
     int len = strlen(msg) - 1;
     msg[len] = '\0';
+    strsubst(msg, '\n', ' ');
 
     prompt_update_statusmessage(prompt, m, msg);
 }
 
+void cmd_nospam(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    long int nospam = rand();
+
+    if (argc > 0) {
+        nospam = strtol(argv[1], NULL, 16);
+
+        if ((nospam == 0 && strcmp(argv[1], "0")) || nospam < 0) {
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid nospam value.");
+            return;
+        }
+    }
+
+    uint32_t old_nospam = tox_self_get_nospam(m);
+    tox_self_set_nospam(m, (uint32_t) nospam);
+
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Your new Tox ID is:");
+    cmd_myid(window, self, m, 0, NULL);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "");
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0,
+                  "Any services that relied on your old ID will need to be updated manually.");
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "If you ever want your old Tox ID back, type '/nospam %X'",
+                  old_nospam);
+}
+
 void cmd_prompt_help(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     help_init_menu(self);
@@ -594,6 +655,9 @@ void cmd_status(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
         msg[len] = '\0';
 
         prompt_update_statusmessage(prompt, m, msg);
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Your status has been changed to %s: \"%s\".", status_str, msg);
+    } else {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Your status has been changed to %s.", status_str);
     }
 
 finish:

src/global_commands.h

@@ -35,8 +35,10 @@ void cmd_decline(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
 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_myqr(WINDOW *window, ToxWindow *self, Tox *m, 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_nospam(WINDOW *window, ToxWindow *self, Tox *m, 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_requests(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
@@ -49,4 +51,13 @@ void cmd_list_devices(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_S
 void cmd_change_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 #endif /* AUDIO */
 
+#ifdef VIDEO
+void cmd_list_video_devices(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_change_video_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+#endif /* VIDEO */
+
+#ifdef PYTHON
+void cmd_run(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+#endif
+
 #endif /* #define GLOBAL_COMMANDS_H */

src/group_commands.c

@@ -30,18 +30,25 @@
 
 void cmd_set_title(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
+    TOX_ERR_CONFERENCE_TITLE err;
     char title[MAX_STR_SIZE];
 
     if (argc < 1) {
-        int tlen = tox_group_get_title(m, self->num, (uint8_t *) title, TOX_MAX_NAME_LENGTH);
+        size_t tlen = tox_conference_get_title_size(m, self->num, &err);
 
-        if (tlen != -1) {
-            title[tlen] = '\0';
-            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Title is set to: %s", title);
-        } else {
+        if (err != TOX_ERR_CONFERENCE_TITLE_OK) {
             line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Title is not set");
+            return;
         }
 
+        if (!tox_conference_get_title(m, self->num, (uint8_t *) title, &err)) {
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Title is not set");
+            return;
+        }
+
+        title[tlen] = '\0';
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Title is set to: %s", title);
+
         return;
     }
 
@@ -55,8 +62,8 @@ void cmd_set_title(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*arg
     int len = strlen(title) - 1;
     title[len] = '\0';
 
-    if (tox_group_set_title(m, self->num, (uint8_t *) title, len) != 0) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set title.");
+    if (!tox_conference_set_title(m, self->num, (uint8_t *) title, len, &err)) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set title (error %d)", err);
         return;
     }
 

src/groupchat.c

@@ -59,7 +59,7 @@
 #include "help.h"
 #include "notify.h"
 #include "autocomplete.h"
-#include "device.h"
+#include "audio_device.h"
 
 extern char *DATA_FILE;
 
@@ -69,10 +69,14 @@ static int max_groupchat_index = 0;
 extern struct user_settings *user_settings;
 extern struct Winthread Winthread;
 
-#ifdef AUDIO
-#define AC_NUM_GROUP_COMMANDS 22
+#if defined(AUDIO) && defined(PYTHON)
+#define AC_NUM_GROUP_COMMANDS 25
+#elif AUDIO
+#define AC_NUM_GROUP_COMMANDS 24
+#elif PYTHON
+#define AC_NUM_GROUP_COMMANDS 21
 #else
-#define AC_NUM_GROUP_COMMANDS 18
+#define AC_NUM_GROUP_COMMANDS 20
 #endif /* AUDIO */
 
 /* Array of groupchat command names used for tab completion. */
@@ -89,32 +93,27 @@ static const char group_cmd_list[AC_NUM_GROUP_COMMANDS][MAX_CMDNAME_SIZE] = {
     { "/help"       },
     { "/log"        },
     { "/myid"       },
+    { "/myqr"       },
     { "/nick"       },
     { "/note"       },
+    { "/nospam"     },
     { "/quit"       },
     { "/requests"   },
     { "/status"     },
     { "/title"      },
 
-#ifdef AUDIO
+#ifdef PYTHON
 
-    { "/lsdev"       },
-    { "/sdev"        },
-    { "/mute"        },
-    { "/sense"       },
+    { "/run"        },
 
-#endif /* AUDIO */
+#endif /* PYTHON */
 };
 
-#ifdef AUDIO
-static int group_audio_open_out_device(int groupnum);
-static int group_audio_close_out_device(int groupnum);
-#endif  /* AUDIO */
-
-int init_groupchat_win(ToxWindow *prompt, Tox *m, int groupnum, uint8_t type)
+int init_groupchat_win(ToxWindow *prompt, Tox *m, uint32_t groupnum, uint8_t type)
 {
-    if (groupnum > MAX_GROUPCHAT_NUM)
+    if (groupnum > MAX_GROUPCHAT_NUM) {
         return -1;
+    }
 
     ToxWindow self = new_group_chat(m, groupnum);
     int i;
@@ -133,18 +132,12 @@ int init_groupchat_win(ToxWindow *prompt, Tox *m, int groupnum, uint8_t type)
             groupchats[i].oldpeer_name_lengths = malloc(sizeof(uint16_t));
 
             if (groupchats[i].peer_names == NULL || groupchats[i].oldpeer_names == NULL
-                || groupchats[i].peer_name_lengths == NULL || groupchats[i].oldpeer_name_lengths == NULL)
+                    || groupchats[i].peer_name_lengths == NULL || groupchats[i].oldpeer_name_lengths == NULL)
                 exit_toxic_err("failed in init_groupchat_win", FATALERR_MEMORY);
 
             memcpy(&groupchats[i].oldpeer_names[0], UNKNOWN_NAME, sizeof(UNKNOWN_NAME));
             groupchats[i].oldpeer_name_lengths[0] = (uint16_t) strlen(UNKNOWN_NAME);
 
-#ifdef AUDIO
-            if (type == TOX_GROUPCHAT_TYPE_AV)
-                if (group_audio_open_out_device(i) == -1)
-                    fprintf(stderr, "Group Audio failed to init\n");
-#endif /* AUDIO */
-
             set_active_window(groupchats[i].chatwin);
 
             if (i == max_groupchat_index)
@@ -172,12 +165,9 @@ static void kill_groupchat_window(ToxWindow *self)
     del_window(self);
 }
 
-void close_groupchat(ToxWindow *self, Tox *m, int groupnum)
+void close_groupchat(ToxWindow *self, Tox *m, uint32_t groupnum)
 {
-    tox_del_groupchat(m, groupnum);
-#ifdef AUDIO
-    group_audio_close_out_device(groupnum);
-#endif
+    tox_conference_delete(m, groupnum, NULL);
 
     free(groupchats[groupnum].peer_names);
     free(groupchats[groupnum].oldpeer_names);
@@ -209,6 +199,9 @@ void redraw_groupchat_win(ToxWindow *self)
     getmaxyx(stdscr, y2, x2);
     y2 -= 2;
 
+    if (y2 <= 0 || x2 <= 0)
+        return;
+
     if (ctx->sidebar) {
         delwin(ctx->sidebar);
         ctx->sidebar = NULL;
@@ -232,8 +225,8 @@ void redraw_groupchat_win(ToxWindow *self)
 
 }
 
-static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, int groupnum, int peernum,
-                                     const char *msg, uint16_t len)
+static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, uint32_t groupnum, uint32_t peernum,
+                                     TOX_MESSAGE_TYPE type, const char *msg, size_t len)
 {
     if (self->num != groupnum)
         return;
@@ -253,7 +246,7 @@ static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, int groupnum, int
 
     /* Only play sound if mentioned by someone else */
     if (strcasestr(msg, selfnick) && strcmp(selfnick, nick)) {
-        sound_notify(self, generic_message, NT_WNDALERT_0, NULL);
+        sound_notify(self, generic_message, NT_WNDALERT_0 | user_settings->bell_on_message, NULL);
 
         if (self->active_box != -1)
             box_silent_notify2(self, NT_NOFOCUS, self->active_box, "%s %s", nick, msg);
@@ -261,56 +254,20 @@ static void groupchat_onGroupMessage(ToxWindow *self, Tox *m, int groupnum, int
             box_silent_notify(self, NT_NOFOCUS, &self->active_box, self->name, "%s %s", nick, msg);
 
         nick_clr = RED;
-    }
-    else {
+    } else {
         sound_notify(self, silent, NT_WNDALERT_1, NULL);
     }
 
     char timefrmt[TIME_STR_SIZE];
     get_time_str(timefrmt, sizeof(timefrmt));
 
-    line_info_add(self, timefrmt, nick, NULL, IN_MSG, 0, nick_clr, "%s", msg);
+    line_info_add(self, timefrmt, nick, NULL, type == TOX_MESSAGE_TYPE_NORMAL ? IN_MSG : IN_ACTION, 0, nick_clr, "%s", msg);
     write_to_log(msg, nick, ctx->log, false);
 }
 
-static void groupchat_onGroupAction(ToxWindow *self, Tox *m, int groupnum, int peernum, const char *action,
-                                    uint16_t len)
-{
-    if (self->num != groupnum)
-        return;
-
-    ChatContext *ctx = self->chatwin;
-
-    char nick[TOX_MAX_NAME_LENGTH];
-    get_group_nick_truncate(m, nick, peernum, groupnum);
-
-    char selfnick[TOX_MAX_NAME_LENGTH];
-    tox_self_get_name(m, (uint8_t *) selfnick);
-
-    size_t n_len = tox_self_get_name_size(m);
-    selfnick[n_len] = '\0';
-
-    if (strcasestr(action, selfnick)) {
-        sound_notify(self, generic_message, NT_WNDALERT_0, NULL);
-
-        if (self->active_box != -1)
-            box_silent_notify2(self, NT_NOFOCUS, self->active_box, "* %s %s", nick, action );
-        else
-            box_silent_notify(self, NT_NOFOCUS, &self->active_box, self->name, "* %s %s", nick, action);
-    }
-    else {
-        sound_notify(self, silent, NT_WNDALERT_1, NULL);
-    }
-
-    char timefrmt[TIME_STR_SIZE];
-    get_time_str(timefrmt, sizeof(timefrmt));
-
-    line_info_add(self, timefrmt, nick, NULL, IN_ACTION, 0, 0, "%s", action);
-    write_to_log(action, nick, ctx->log, true);
-}
-
-static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, int groupnum, int peernum, const char *title,
-                                         uint8_t length)
+static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, uint32_t groupnum, uint32_t peernum,
+        const char *title,
+        size_t length)
 {
     ChatContext *ctx = self->chatwin;
 
@@ -323,7 +280,7 @@ static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, int groupnum,
     get_time_str(timefrmt, sizeof(timefrmt));
 
     /* don't announce title when we join the room */
-    if (!timed_out(groupchats[self->num].start_time, get_unix_time(), GROUP_EVENT_WAIT))
+    if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT))
         return;
 
     char nick[TOX_MAX_NAME_LENGTH];
@@ -336,7 +293,7 @@ static void groupchat_onGroupTitleChange(ToxWindow *self, Tox *m, int groupnum,
 }
 
 /* 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)
+static void copy_peernames(Tox *m, uint32_t gnum, size_t npeers)
 {
     /* Assumes these are initiated in init_groupchat_win */
     free(groupchats[gnum].peer_names);
@@ -346,27 +303,34 @@ static void copy_peernames(int gnum, uint8_t peerlist[][TOX_MAX_NAME_LENGTH], ui
 
     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);
+    groupchats[gnum].peer_names = calloc(1, sizeof(uint8_t) * npeers * N);
+    groupchats[gnum].oldpeer_names = calloc(1, sizeof(uint8_t) * npeers * N);
+    groupchats[gnum].peer_name_lengths = calloc(1, sizeof(uint16_t) * npeers);
+    groupchats[gnum].oldpeer_name_lengths = calloc(1, sizeof(uint16_t) * npeers);
 
     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);
+            || groupchats[gnum].peer_name_lengths == NULL || groupchats[gnum].oldpeer_name_lengths == NULL) {
+        exit_toxic_err("failed in copy_peernames()", FATALERR_MEMORY);
     }
 
     uint16_t u_len = strlen(UNKNOWN_NAME);
+
     int i;
 
     for (i = 0; i < npeers; ++i) {
-         if (!lengths[i]) {
+        uint8_t name[TOX_MAX_NAME_LENGTH];
+        TOX_ERR_CONFERENCE_PEER_QUERY err;
+
+        size_t n_len = tox_conference_peer_get_name_size(m, gnum, i, &err);
+
+        if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
             memcpy(&groupchats[gnum].peer_names[i * N], UNKNOWN_NAME, u_len);
             groupchats[gnum].peer_names[i * N + u_len] = '\0';
             groupchats[gnum].peer_name_lengths[i] = u_len;
         } else {
-            uint16_t n_len = MIN(lengths[i], TOXIC_MAX_NAME_LENGTH - 1);
-            memcpy(&groupchats[gnum].peer_names[i * N], peerlist[i], n_len);
+            tox_conference_peer_get_name(m, gnum, i, name, NULL);
+            n_len = MIN(n_len, TOXIC_MAX_NAME_LENGTH - 1);
+            memcpy(&groupchats[gnum].peer_names[i * N], name, n_len);
             groupchats[gnum].peer_names[i * N + n_len] = '\0';
             groupchats[gnum].peer_name_lengths[i] = n_len;
             filter_str((char *) &groupchats[gnum].peer_names[i * N], n_len);
@@ -380,9 +344,9 @@ static void copy_peernames(int gnum, uint8_t peerlist[][TOX_MAX_NAME_LENGTH], ui
 struct group_add_thrd {
     Tox *m;
     ToxWindow *self;
-    int peernum;
-    int groupnum;
-    uint64_t timestamp;
+    uint32_t peernum;
+    uint32_t groupnum;
+    time_t timestamp;
     pthread_t tid;
     pthread_attr_t attr;
 };
@@ -402,7 +366,7 @@ void *group_add_wait(void *data)
         pthread_mutex_lock(&Winthread.lock);
         get_group_nick_truncate(m, peername, thrd->peernum, thrd->groupnum);
 
-        if (strcmp(peername, DEFAULT_TOX_NAME) || timed_out(thrd->timestamp, get_unix_time(), GROUP_EVENT_WAIT)) {
+        if (strcmp(peername, DEFAULT_TOX_NAME) || timed_out(thrd->timestamp, GROUP_EVENT_WAIT)) {
             pthread_mutex_unlock(&Winthread.lock);
             break;
         }
@@ -424,7 +388,8 @@ void *group_add_wait(void *data)
     pthread_exit(NULL);
 }
 
-static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnum, int peernum, uint8_t change)
+static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, uint32_t groupnum, uint32_t peernum,
+        TOX_CONFERENCE_STATE_CHANGE change)
 {
     if (self->num != groupnum)
         return;
@@ -432,8 +397,15 @@ static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnu
     if (groupnum > max_groupchat_index)
         return;
 
-    groupchats[groupnum].num_peers = tox_group_number_peers(m, groupnum);
-    int num_peers = groupchats[groupnum].num_peers;
+    TOX_ERR_CONFERENCE_PEER_QUERY err;
+
+    uint32_t num_peers = tox_conference_peer_count(m, groupnum, &err);
+
+    if (err == TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
+        groupchats[groupnum].num_peers = num_peers;
+    } else {
+        num_peers = groupchats[groupnum].num_peers;
+    }
 
     if (peernum > num_peers)
         return;
@@ -441,28 +413,19 @@ static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnu
     /* get old peer name before updating name list */
     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],
-               sizeof(oldpeername));
+    if (change != TOX_CONFERENCE_STATE_CHANGE_PEER_JOIN) {
+        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/len lists */
-    uint8_t tmp_peerlist[num_peers][TOX_MAX_NAME_LENGTH];
-    uint16_t tmp_peerlens[num_peers];
-
-    if (tox_group_get_names(m, groupnum, tmp_peerlist, tmp_peerlens, num_peers) == -1) {
-        memset(tmp_peerlist, 0, sizeof(tmp_peerlist));
-        memset(tmp_peerlens, 0, sizeof(tmp_peerlens));
-    }
-
-    copy_peernames(groupnum, tmp_peerlist, tmp_peerlens, num_peers);
+    copy_peernames(m, groupnum, num_peers);
 
     /* get current peername then sort namelist */
     uint8_t peername[TOX_MAX_NAME_LENGTH];
 
-    if (change != TOX_CHAT_CHANGE_PEER_DEL) {
+    if (change != TOX_CONFERENCE_STATE_CHANGE_PEER_EXIT) {
         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';
@@ -477,8 +440,8 @@ static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnu
     get_time_str(timefrmt, sizeof(timefrmt));
 
     switch (change) {
-        case TOX_CHAT_CHANGE_PEER_ADD:
-            if (!timed_out(groupchats[groupnum].start_time, get_unix_time(), GROUP_EVENT_WAIT))
+        case TOX_CONFERENCE_STATE_CHANGE_PEER_JOIN:
+            if (!timed_out(groupchats[groupnum].start_time, GROUP_EVENT_WAIT))
                 break;
 
             struct group_add_thrd *thrd = malloc(sizeof(struct group_add_thrd));
@@ -507,7 +470,7 @@ static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnu
 
             break;
 
-        case TOX_CHAT_CHANGE_PEER_DEL:
+        case TOX_CONFERENCE_STATE_CHANGE_PEER_EXIT:
             event = "has left the room";
             line_info_add(self, timefrmt, (char *) oldpeername, NULL, DISCONNECTION, 0, RED, event);
 
@@ -517,8 +480,8 @@ static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnu
             write_to_log(event, (char *) oldpeername, ctx->log, true);
             break;
 
-        case TOX_CHAT_CHANGE_PEER_NAME:
-            if (!timed_out(groupchats[self->num].start_time, get_unix_time(), GROUP_EVENT_WAIT))
+        case TOX_CONFERENCE_STATE_CHANGE_PEER_NAME_CHANGE:
+            if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT))
                 return;
 
             /* ignore initial name change (TODO: this is a bad way to do this) */
@@ -544,9 +507,10 @@ static void send_group_action(ToxWindow *self, ChatContext *ctx, Tox *m, char *a
         return;
     }
 
-    if (tox_group_action_send(m, self->num, (uint8_t *) action, strlen(action)) == -1) {
-        const char *errmsg = " * Failed to send action.";
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, errmsg);
+    TOX_ERR_CONFERENCE_SEND_MESSAGE err;
+
+    if (!tox_conference_send_message(m, self->num, TOX_MESSAGE_TYPE_ACTION, (uint8_t *) action, strlen(action), &err)) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, " * Failed to send action (error %d)", err);
     }
 }
 
@@ -558,7 +522,7 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     getyx(self->window, y, x);
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= 0)
+    if (x2 <= 0 || y2 <= 0)
         return;
 
     if (self->help->active) {
@@ -566,7 +530,10 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
         return;
     }
 
-    if (ltr) {    /* char is printable */
+    if (ctx->pastemode && key == '\r')
+        key = '\n';
+
+    if (ltr || key == '\n') {    /* char is printable */
         input_new_char(self, key, x, y, x2, y2);
         return;
     }
@@ -587,13 +554,22 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
                                      TOX_MAX_NAME_LENGTH);
             } else if (wcsncmp(ctx->line, L"/avatar \"", wcslen(L"/avatar \"")) == 0) {
                 diff = dir_match(self, m, ctx->line, L"/avatar");
-            } else {
+            }
+
+#ifdef PYTHON
+            else if (wcsncmp(ctx->line, L"/run \"", wcslen(L"/run \"")) == 0) {
+                diff = dir_match(self, m, ctx->line, L"/run");
+            }
+
+#endif
+
+            else {
                 diff = complete_line(self, group_cmd_list, AC_NUM_GROUP_COMMANDS, MAX_CMDNAME_SIZE);
             }
 
             if (diff != -1) {
                 if (x + diff > x2 - 1) {
-                    int wlen = wcswidth(ctx->line, sizeof(ctx->line));
+                    int wlen = MAX(0, wcswidth(ctx->line, sizeof(ctx->line) / sizeof(wchar_t)));
                     ctx->start = wlen < x2 ? 0 : wlen - x2 + 1;
                 }
             } else {
@@ -610,30 +586,34 @@ static void groupchat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     } else if (key == user_settings->key_peer_list_up) {
         if (groupchats[self->num].side_pos > 0)
             --groupchats[self->num].side_pos;
-    } else if (key == '\n') {
+    } else if (key == '\r') {
         rm_trailing_spaces_buf(ctx);
 
-        char line[MAX_STR_SIZE];
-
-        if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
-            memset(&line, 0, sizeof(line));
-
-        if (!string_is_empty(line))
+        if (!wstring_is_empty(ctx->line)) {
             add_line_to_hist(ctx);
 
-        if (line[0] == '/') {
-            if (strcmp(line, "/close") == 0) {
-                close_groupchat(self, m, self->num);
-                return;
-            } else if (strncmp(line, "/me ", strlen("/me ")) == 0) {
-                send_group_action(self, ctx, m, line + strlen("/me "));
+            wstrsubst(ctx->line, L'¶', L'\n');
+
+            char line[MAX_STR_SIZE];
+
+            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
+                memset(&line, 0, sizeof(line));
+
+            if (line[0] == '/') {
+                if (strcmp(line, "/close") == 0) {
+                    close_groupchat(self, m, self->num);
+                    return;
+                } 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 {
-                execute(ctx->history, self, m, line, GROUPCHAT_COMMAND_MODE);
-            }
-        } else if (!string_is_empty(line)) {
-            if (tox_group_message_send(m, self->num, (uint8_t *) line, strlen(line)) == -1) {
-                const char *errmsg = " * Failed to send message.";
-                line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, errmsg);
+                TOX_ERR_CONFERENCE_SEND_MESSAGE err;
+
+                if (!tox_conference_send_message(m, self->num, TOX_MESSAGE_TYPE_NORMAL, (uint8_t *) line, strlen(line), &err)) {
+                    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, " * Failed to send message (error %d)", err);
+                }
             }
         }
 
@@ -648,9 +628,15 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
+    if (x2 <= 0 || y2 <= 0)
+        return;
+
     ChatContext *ctx = self->chatwin;
 
+    pthread_mutex_lock(&Winthread.lock);
     line_info_print(self);
+    pthread_mutex_unlock(&Winthread.lock);
+
     wclear(ctx->linewin);
 
     curs_set(1);
@@ -665,7 +651,9 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
         mvwvline(ctx->sidebar, 0, 0, ACS_VLINE, y2 - CHATBOX_HEIGHT);
         mvwaddch(ctx->sidebar, y2 - CHATBOX_HEIGHT, 0, ACS_BTEE);
 
+        pthread_mutex_lock(&Winthread.lock);
         int num_peers = groupchats[self->num].num_peers;
+        pthread_mutex_unlock(&Winthread.lock);
 
         wmove(ctx->sidebar, 0, 1);
         wattron(ctx->sidebar, A_BOLD);
@@ -680,12 +668,19 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
 
         for (i = 0; i < num_peers && i < maxlines; ++i) {
             wmove(ctx->sidebar, i + 2, 1);
-            int peer = i + groupchats[self->num].side_pos;
+
+            pthread_mutex_lock(&Winthread.lock);
+            uint32_t peer = i + groupchats[self->num].side_pos;
+            pthread_mutex_unlock(&Winthread.lock);
 
             /* truncate nick to fit in side panel without modifying list */
             char tmpnck[TOX_MAX_NAME_LENGTH];
             int maxlen = SIDEBAR_WIDTH - 2;
+
+            pthread_mutex_lock(&Winthread.lock);
             memcpy(tmpnck, &groupchats[self->num].peer_names[peer * TOX_MAX_NAME_LENGTH], maxlen);
+            pthread_mutex_unlock(&Winthread.lock);
+
             tmpnck[maxlen] = '\0';
 
             wprintw(ctx->sidebar, "%s\n", tmpnck);
@@ -695,10 +690,10 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
     int y, x;
     getyx(self->window, y, x);
     (void) x;
-    int new_x = ctx->start ? x2 - 1 : wcswidth(ctx->line, ctx->pos);
+    int new_x = ctx->start ? x2 - 1 : MAX(0, wcswidth(ctx->line, ctx->pos));
     wmove(self->window, y + 1, new_x);
 
-    wrefresh(self->window);
+    wnoutrefresh(self->window);
 
     if (self->help->active)
         help_onDraw(self);
@@ -709,6 +704,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
+    if (x2 <= 0 || y2 <= 0)
+        exit_toxic_err("failed in groupchat_onInit", FATALERR_CURSES);
+
     ChatContext *ctx = self->chatwin;
 
     ctx->history = subwin(self->window, y2 - CHATBOX_HEIGHT + 1, x2 - SIDEBAR_WIDTH - 1, 0, 0);
@@ -726,7 +724,9 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
     if (user_settings->autolog == AUTOLOG_ON) {
         char myid[TOX_ADDRESS_SIZE];
         tox_self_get_address(m, (uint8_t *) myid);
-        log_enable(self->name, myid, NULL, ctx->log, LOG_GROUP);
+
+        if (log_enable(self->name, myid, NULL, ctx->log, LOG_GROUP) == -1)
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
     }
 
     execute(ctx->history, self, m, "/log", GLOBAL_COMMAND_MODE);
@@ -735,125 +735,7 @@ static void groupchat_onInit(ToxWindow *self, Tox *m)
     wmove(self->window, y2 - CURS_Y_OFFSET, 0);
 }
 
-
-#ifdef AUDIO
-static int group_audio_open_out_device(int groupnum)
-{
-    char dname[MAX_STR_SIZE];
-    get_primary_device_name(output, dname, sizeof(dname));
-    dname[MAX_STR_SIZE - 1] = '\0';
-
-    groupchats[groupnum].audio.dvhandle = alcOpenDevice(dname);
-
-    if (groupchats[groupnum].audio.dvhandle == NULL)
-        return -1;
-
-    groupchats[groupnum].audio.dvctx = alcCreateContext(groupchats[groupnum].audio.dvhandle, NULL);
-    alcMakeContextCurrent(groupchats[groupnum].audio.dvctx);
-    alGenBuffers(OPENAL_BUFS, groupchats[groupnum].audio.buffers);
-    alGenSources((uint32_t) 1, &groupchats[groupnum].audio.source);
-    alSourcei(groupchats[groupnum].audio.source, AL_LOOPING, AL_FALSE);
-
-    if (alcGetError(groupchats[groupnum].audio.dvhandle) != AL_NO_ERROR) {
-        group_audio_close_out_device(groupnum);
-        groupchats[groupnum].audio.dvhandle = NULL;
-        groupchats[groupnum].audio.dvctx = NULL;
-        return -1;
-    }
-
-    alSourceQueueBuffers(groupchats[groupnum].audio.source, OPENAL_BUFS, groupchats[groupnum].audio.buffers);
-    alSourcePlay(groupchats[groupnum].audio.source);
-
-    return 0;
-}
-
-static int group_audio_close_out_device(int groupnum)
-{
-    if (!groupchats[groupnum].audio.dvhandle)
-        return -1;
-
-    if (!groupchats[groupnum].audio.dvctx)
-        return -1;
-
-    if (alcGetCurrentContext() != groupchats[groupnum].audio.dvctx)
-        alcMakeContextCurrent(groupchats[groupnum].audio.dvctx);
-
-    alDeleteSources((uint32_t) 1, &groupchats[groupnum].audio.source);
-    alDeleteBuffers(OPENAL_BUFS, groupchats[groupnum].audio.buffers);
-
-    alcMakeContextCurrent(NULL);
-    alcDestroyContext(groupchats[groupnum].audio.dvctx);
-
-    if (!alcCloseDevice(groupchats[groupnum].audio.dvhandle))
-        return -1;
-
-    return 0;
-}
-
-static int group_audio_write(int peernum, int groupnum, const int16_t *pcm, unsigned int samples, uint8_t channels,
-                             unsigned int sample_rate)
-{
-    if (!pcm)
-        return -1;
-
-    if (channels == 0 || channels > 2)
-        return -2;
-
-    ALuint bufid;
-    ALint processed = 0, queued = 0;
-
-    alGetSourcei(groupchats[groupnum].audio.source, AL_BUFFERS_PROCESSED, &processed);
-    alGetSourcei(groupchats[groupnum].audio.source, AL_BUFFERS_QUEUED, &queued);
-    fprintf(stderr, "source: %d, queued: %d, processed: %d\n", groupchats[groupnum].audio.source, queued, processed);
-
-    if (processed) {
-        ALuint bufids[processed];
-        alSourceUnqueueBuffers(groupchats[groupnum].audio.source, processed, bufids);
-        alDeleteBuffers(processed - 1, bufids + 1);
-        bufid = bufids[0];
-    } else if (queued < 16) {
-        alGenBuffers(1, &bufid);
-    } else {
-        return -3;
-    }
-
-    int length = samples * channels * sizeof(int16_t);
-
-    alBufferData(bufid, (channels == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16, pcm, length, sample_rate);
-    alSourceQueueBuffers(groupchats[groupnum].audio.source, 1, &bufid);
-
-    ALint state;
-    alGetSourcei(groupchats[groupnum].audio.source, AL_SOURCE_STATE, &state);
-
-    if (state != AL_PLAYING)
-        alSourcePlay(groupchats[groupnum].audio.source);
-
-    return 0;
-}
-
-static void groupchat_onWriteDevice(ToxWindow *self, Tox *m, int groupnum, int peernum, const int16_t *pcm,
-                                    unsigned int samples, uint8_t channels, unsigned int sample_rate)
-{
-    return;
-
-    if (groupnum != self->num)
-        return;
-
-    if (peernum < 0)
-        return;
-
-    if (groupchats[groupnum].audio.dvhandle == NULL)
-        fprintf(stderr, "dvhandle is null)\n");
-
-    if (groupchats[groupnum].audio.dvctx == NULL)
-        fprintf(stderr, "ctx is null\n");
-
-    int ret = group_audio_write(peernum, groupnum, pcm, samples, channels, sample_rate);
-    fprintf(stderr, "write: %d\n", ret);
-}
-#endif  /* AUDIO */
-
-ToxWindow new_group_chat(Tox *m, int groupnum)
+ToxWindow new_group_chat(Tox *m, uint32_t groupnum)
 {
     ToxWindow ret;
     memset(&ret, 0, sizeof(ret));
@@ -866,13 +748,8 @@ ToxWindow new_group_chat(Tox *m, int groupnum)
     ret.onInit = &groupchat_onInit;
     ret.onGroupMessage = &groupchat_onGroupMessage;
     ret.onGroupNamelistChange = &groupchat_onGroupNamelistChange;
-    ret.onGroupAction = &groupchat_onGroupAction;
     ret.onGroupTitleChange = &groupchat_onGroupTitleChange;
 
-#ifdef AUDIO
-    ret.onWriteDevice = &groupchat_onWriteDevice;
-#endif
-
     snprintf(ret.name, sizeof(ret.name), "Group %d", groupnum);
 
     ChatContext *chatwin = calloc(1, sizeof(ChatContext));

src/groupchat.h

@@ -26,61 +26,30 @@
 #include "toxic.h"
 #include "windows.h"
 
-#ifdef AUDIO
-#include "audio_call.h"
-#endif
-
-#ifdef AUDIO
-#ifdef __APPLE__
-#include <OpenAL/al.h>
-#include <OpenAL/alc.h>
-#else
-#include <AL/al.h>
-#include <AL/alc.h>
-/* compatibility with older versions of OpenAL */
-#ifndef ALC_ALL_DEVICES_SPECIFIER
-#include <AL/alext.h>
-#endif  /* ALC_ALL_DEVICES_SPECIFIER */
-#endif  /* __APPLE__ */
-#endif  /* AUDIO */
-
 #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 - 2
 #define GROUP_EVENT_WAIT 3
 
-#ifdef AUDIO
-struct GAudio {
-    ALCdevice  *dvhandle;    /* Handle of device selected/opened */
-    ALCcontext *dvctx;
-    ALuint source;
-    ALuint buffers[OPENAL_BUFS];
-};
-#endif  /* AUDIO */
-
 typedef struct {
     int chatwin;
     bool active;
     uint8_t type;
-    int num_peers;
+    uint32_t num_peers;
     int side_pos;    /* current position of the sidebar - used for scrolling up and down */
-    uint64_t start_time;
+    time_t start_time;
     uint8_t  *peer_names;
     uint8_t  *oldpeer_names;
     uint16_t *peer_name_lengths;
     uint16_t *oldpeer_name_lengths;
-
-#ifdef AUDIO
-    struct GAudio audio;
-#endif
 } GroupChat;
 
-void close_groupchat(ToxWindow *self, Tox *m, int groupnum);
-int init_groupchat_win(ToxWindow *prompt, Tox *m, int groupnum, uint8_t type);
+void close_groupchat(ToxWindow *self, Tox *m, uint32_t groupnum);
+int init_groupchat_win(ToxWindow *prompt, Tox *m, uint32_t groupnum, uint8_t type);
 
 /* destroys and re-creates groupchat window with or without the peerlist */
 void redraw_groupchat_win(ToxWindow *self);
 
-ToxWindow new_group_chat(Tox *m, int groupnum);
+ToxWindow new_group_chat(Tox *m, uint32_t groupnum);
 
 #endif /* #define GROUPCHAT_H */

src/help.c

@@ -27,7 +27,15 @@
 #include "help.h"
 #include "misc_tools.h"
 
+#ifdef PYTHON
+#include "api.h"
+#endif /* PYTHON */
+
+#ifdef PYTHON
+#define HELP_MENU_HEIGHT 10
+#else
 #define HELP_MENU_HEIGHT 9
+#endif /* PYTHON */
 #define HELP_MENU_WIDTH 26
 
 void help_init_menu(ToxWindow *self)
@@ -60,6 +68,9 @@ static void help_init_window(ToxWindow *self, int height, int width)
     int y2, x2;
     getmaxyx(stdscr, y2, x2);
 
+    if (y2 <= 0 || x2 <= 0)
+        return;
+
     height = MIN(height, y2);
     width = MIN(width, x2);
 
@@ -92,6 +103,13 @@ static void help_draw_menu(ToxWindow *self)
     wattroff(win, A_BOLD | COLOR_PAIR(BLUE));
     wprintw(win, "oup commands\n");
 
+#ifdef PYTHON
+    wattron(win, A_BOLD | COLOR_PAIR(BLUE));
+    wprintw(win, " p");
+    wattroff(win, A_BOLD | COLOR_PAIR(BLUE));
+    wprintw(win, "lugin commands\n");
+#endif /* PYTHON */
+
     wattron(win, A_BOLD | COLOR_PAIR(BLUE));
     wprintw(win, " f");
     wattroff(win, A_BOLD | COLOR_PAIR(BLUE));
@@ -109,7 +127,7 @@ static void help_draw_menu(ToxWindow *self)
     wprintw(win, "it menu\n");
 
     box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    wnoutrefresh(win);
 }
 
 static void help_draw_bottom_menu(WINDOW *win)
@@ -144,16 +162,22 @@ static void help_draw_global(ToxWindow *self)
 
     wprintw(win, "  /add <addr> <msg>          : Add contact with optional message\n");
     wprintw(win, "  /accept <id>               : Accept friend request\n");
-    wprintw(win, "  /avatar <path>             : Set a personal avatar\n");
+    wprintw(win, "  /avatar <path>             : Set an avatar (leave path empty to unset)\n");
     wprintw(win, "  /decline <id>              : Decline friend request\n");
     wprintw(win, "  /requests                  : List pending friend requests\n");
     wprintw(win, "  /connect <ip> <port> <key> : Manually connect to a DHT node\n");
     wprintw(win, "  /status <type> <msg>       : Set status with optional note\n");
     wprintw(win, "  /note <msg>                : Set a personal note\n");
     wprintw(win, "  /nick <nick>               : Set your nickname\n");
+    wprintw(win, "  /nospam <value>            : Change part of your Tox ID to stop spam\n");
     wprintw(win, "  /log <on> or <off>         : Enable/disable logging\n");
     wprintw(win, "  /group <type>              : Create a group chat where type: text | audio\n");
     wprintw(win, "  /myid                      : Print your Tox ID\n");
+#ifdef QRPNG
+    wprintw(win, "  /myqr <txt> or <png>       : Print your Tox ID's QR code to a file.\n");
+#else
+    wprintw(win, "  /myqr                      : Print your Tox ID's QR code to a file.\n");
+#endif /* QRPNG */
     wprintw(win, "  /clear                     : Clear window history\n");
     wprintw(win, "  /close                     : Close the current chat window\n");
     wprintw(win, "  /quit or /exit             : Exit Toxic\n");
@@ -167,10 +191,27 @@ static void help_draw_global(ToxWindow *self)
     wprintw(win, "  /sdev <type> <id>          : Set active device\n");
 #endif /* AUDIO */
 
+#ifdef VIDEO
+    wattron(win, A_BOLD);
+    wprintw(win, "\n Video:\n");
+    wattroff(win, A_BOLD);
+
+    wprintw(win, "  /lsvdev <type>             : List video devices where type: in|out\n");
+    wprintw(win, "  /svdev <type> <id>         : Set active video device\n");
+#endif /* VIDEO */
+
+#ifdef PYTHON
+    wattron(win, A_BOLD);
+    wprintw(win, "\n Scripting:\n");
+    wattroff(win, A_BOLD);
+
+    wprintw(win, "  /run <path>                : Load and run the script at path\n");
+#endif /* PYTHON */
+
     help_draw_bottom_menu(win);
 
     box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    wnoutrefresh(win);
 }
 
 static void help_draw_chat(ToxWindow *self)
@@ -201,12 +242,20 @@ static void help_draw_chat(ToxWindow *self)
     wprintw(win, "  /sdev <type> <id>          : Change active device\n");
     wprintw(win, "  /mute <type>               : Mute active device if in call\n");
     wprintw(win, "  /sense <n>                 : VAD sensitivity threshold\n");
+    wprintw(win, "  /bitrate <n>               : Set the audio encoding bitrate\n");
 #endif /* AUDIO */
 
+#ifdef VIDEO
+    wattron(win, A_BOLD);
+    wprintw(win, "\n Video:\n");
+    wattroff(win, A_BOLD);
+    wprintw(win, "  /video                     : Toggle video call\n");
+#endif /* VIDEO */
+
     help_draw_bottom_menu(win);
 
     box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    wnoutrefresh(win);
 }
 
 static void help_draw_keys(ToxWindow *self)
@@ -219,18 +268,20 @@ static void help_draw_keys(ToxWindow *self)
     wprintw(win, "Key bindings:\n");
     wattroff(win, A_BOLD | COLOR_PAIR(RED));
 
-    wprintw(win, "  Ctrl+O and Ctrl+P         : Navigate through the tabs\n"); 
+    wprintw(win, "  Ctrl+O and Ctrl+P         : Navigate through the tabs\n");
     wprintw(win, "  Page Up and Page Down     : Scroll window history one line\n");
     wprintw(win, "  Ctrl+F and Ctrl+V         : Scroll window history half a page\n");
     wprintw(win, "  Ctrl+H                    : Move to the bottom of window history\n");
     wprintw(win, "  Ctrl+[ and Ctrl+]         : Scroll peer list in groupchats\n");
-    wprintw(win, "  Ctrl+B                    : Toggle the groupchat peerlist\n\n");
+    wprintw(win, "  Ctrl+B                    : Toggle the groupchat peerlist\n");
+    wprintw(win, "  Ctrl+J                    : Insert new line\n");
+    wprintw(win, "  Ctrl+T                    : Toggle paste mode\n\n");
     wprintw(win, "  (Note: Custom keybindings override these defaults.)\n\n");
 
     help_draw_bottom_menu(win);
 
     box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    wnoutrefresh(win);
 }
 
 static void help_draw_group(ToxWindow *self)
@@ -245,18 +296,31 @@ static void help_draw_group(ToxWindow *self)
 
     wprintw(win, "  /title <msg>               : Set group title (show current title if no msg)\n\n");
 
-    wattron(win, A_BOLD);
-    wprintw(win, " Audio commands:\n");
-    wattroff(win, A_BOLD);
+    help_draw_bottom_menu(win);
 
-    wprintw(win, "  /mute <type>               : Mute active device where type: in | out\n");
-    wprintw(win, "  /sense <n>                 : VAD sensitivity threshold\n\n");
+    box(win, ACS_VLINE, ACS_HLINE);
+    wnoutrefresh(win);
+}
+
+#ifdef PYTHON
+static void help_draw_plugin(ToxWindow *self)
+{
+    WINDOW *win = self->help->win;
+
+    wmove(win, 1, 1);
+
+    wattron(win, A_BOLD | COLOR_PAIR(RED));
+    wprintw(win, "Plugin commands:\n");
+    wattroff(win, A_BOLD | COLOR_PAIR(RED));
+
+    draw_handler_help(win);
 
     help_draw_bottom_menu(win);
 
     box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    wnoutrefresh(win);
 }
+#endif
 
 static void help_draw_contacts(ToxWindow *self)
 {
@@ -277,40 +341,55 @@ static void help_draw_contacts(ToxWindow *self)
     help_draw_bottom_menu(win);
 
     box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    wnoutrefresh(win);
 }
 
 void help_onKey(ToxWindow *self, wint_t key)
 {
-    switch(key) {
+    int height;
+
+    switch (key) {
         case 'x':
         case T_KEY_ESC:
             help_exit(self);
             break;
 
         case 'c':
-#ifdef AUDIO
-            help_init_window(self, 19, 80);
+#ifdef VIDEO
+            help_init_window(self, 23, 80);
+#elif AUDIO
+            help_init_window(self, 20, 80);
 #else
-            help_init_window(self, 9, 80);
+            help_init_window(self, 10, 80);
 #endif
             self->help->type = HELP_CHAT;
             break;
 
         case 'g':
-#ifdef AUDIO
-            help_init_window(self, 24, 80);
-#else
-            help_init_window(self, 20, 80);
+            height = 22;
+#ifdef VIDEO
+            height += 8;
+#elif AUDIO
+            height += 4;
 #endif
+#ifdef PYTHON
+            height += 2;
+#endif
+            help_init_window(self, height, 80);
             self->help->type = HELP_GLOBAL;
             break;
 
-#ifdef AUDIO    /* remove if/when we add non-audio group commands */
         case 'r':
-            help_init_window(self, 10, 80);
+            help_init_window(self, 6, 80);
             self->help->type = HELP_GROUP;
             break;
+
+#ifdef PYTHON
+
+        case 'p':
+            help_init_window(self, 4 + num_registered_handlers(), help_max_width());
+            self->help->type = HELP_PLUGIN;
+            break;
 #endif
 
         case 'f':
@@ -319,7 +398,7 @@ void help_onKey(ToxWindow *self, wint_t key)
             break;
 
         case 'k':
-            help_init_window(self, 13, 80);
+            help_init_window(self, 15, 80);
             self->help->type = HELP_KEYS;
             break;
 
@@ -332,9 +411,7 @@ void help_onKey(ToxWindow *self, wint_t key)
 
 void help_onDraw(ToxWindow *self)
 {
-    curs_set(0);
-
-    switch(self->help->type) {
+    switch (self->help->type) {
         case HELP_MENU:
             help_draw_menu(self);
             return;
@@ -358,5 +435,12 @@ void help_onDraw(ToxWindow *self)
         case HELP_GROUP:
             help_draw_group(self);
             break;
+
+#ifdef PYTHON
+
+        case HELP_PLUGIN:
+            help_draw_plugin(self);
+            break;
+#endif /* PYTHON */
     }
 }

src/help.h

@@ -33,6 +33,9 @@ typedef enum {
     HELP_GROUP,
     HELP_KEYS,
     HELP_CONTACTS,
+#ifdef PYTHON
+    HELP_PLUGIN,
+#endif
 } HELP_TYPES;
 
 void help_onDraw(ToxWindow *self);

src/input.c

@@ -42,9 +42,12 @@ void input_new_char(ToxWindow *self, wint_t key, int x, int y, int mx_x, int mx_
 {
     ChatContext *ctx = self->chatwin;
 
+    /* this is the only place we need to do this check */
+    if (key == '\n')
+        key = L'¶';
+
     int cur_len = wcwidth(key);
 
-    /* this is the only place we need to do this check */
     if (cur_len == -1) {
         sound_notify(self, notif_error, 0, NULL);
         return;
@@ -125,7 +128,7 @@ static void input_yank(ToxWindow *self, int x, int mx_x)
 
     if (x + yank_cols >= mx_x) {
         int rmdr = MAX(0, (x + yank_cols) - mx_x);
-        int s_len = wcswidth(&ctx->line[ctx->start], rmdr);
+        int s_len = MAX(0, wcswidth(&ctx->line[ctx->start], rmdr));
         ctx->start += s_len + 1;
     }
 }
@@ -137,7 +140,7 @@ static void input_mv_end(ToxWindow *self, int y, int mx_x)
 
     ctx->pos = ctx->len;
 
-    int wlen = wcswidth(ctx->line, sizeof(ctx->line));
+    int wlen = MAX(0, wcswidth(ctx->line, sizeof(ctx->line) / sizeof(wchar_t)));
     ctx->start = MAX(0, 1 + (mx_x * (wlen / mx_x) - mx_x) + (wlen % mx_x));
 }
 
@@ -196,7 +199,7 @@ static void input_history(ToxWindow *self, wint_t key, int mx_x)
     ChatContext *ctx = self->chatwin;
 
     fetch_hist_item(ctx, key);
-    int wlen = wcswidth(ctx->line, sizeof(ctx->line));
+    int wlen = MAX(0, wcswidth(ctx->line, sizeof(ctx->line) / sizeof(wchar_t)));
     ctx->start = wlen < mx_x ? 0 : wlen - mx_x + 1;
 }
 
@@ -266,15 +269,19 @@ bool input_handle(ToxWindow *self, wint_t key, int x, int y, int mx_x, int mx_y)
 
     /* TODO: this special case is ugly.
        maybe convert entire function to if/else and make them all customizable keys? */
-    if (!match && key == user_settings->key_toggle_peerlist) {
-        if (self->is_groupchat) {
-            self->show_peerlist ^= 1;
-            redraw_groupchat_win(self);
+    if (!match) {
+        if (key == user_settings->key_toggle_peerlist) {
+            if (self->is_groupchat) {
+                self->show_peerlist ^= 1;
+                redraw_groupchat_win(self);
+            }
+
+            match = true;
+        } else if (key == user_settings->key_toggle_pastemode) {
+            self->chatwin->pastemode ^= 1;
+            match = true;
         }
-
-        match = true;
     }
 
-
     return match;
 }

src/line_info.c

@@ -129,14 +129,21 @@ static struct line_info *line_info_ret_queue(struct history *hst)
     return line;
 }
 
-/* creates new line_info line and puts it in the queue. */
-void line_info_add(ToxWindow *self, const char *timestr, const char *name1, const char *name2, uint8_t type,
-                   uint8_t bold, uint8_t colour, const char *msg, ...)
+/* creates new line_info line and puts it in the queue.
+ *
+ * Returns the id of the new line.
+ * Returns -1 on failure.
+ */
+int line_info_add(ToxWindow *self, const char *timestr, const char *name1, const char *name2, uint8_t type,
+                  uint8_t bold, uint8_t colour, const char *msg, ...)
 {
+    if (!self)
+        return -1;
+
     struct history *hst = self->chatwin->hst;
 
     if (hst->queue_sz >= MAX_LINE_INFO_QUEUE)
-        return;
+        return -1;
 
     struct line_info *new_line = calloc(1, sizeof(struct line_info));
 
@@ -155,11 +162,15 @@ void line_info_add(ToxWindow *self, const char *timestr, const char *name1, cons
     /* for type-specific formatting in print function */
     switch (type) {
         case IN_ACTION:
+
+        /* fallthrough */
         case OUT_ACTION:
             len += strlen(user_settings->line_normal) + 2;
             break;
 
         case IN_MSG:
+
+        /* fallthrough */
         case OUT_MSG:
             len += strlen(user_settings->line_normal) + 3;
             break;
@@ -215,6 +226,7 @@ void line_info_add(ToxWindow *self, const char *timestr, const char *name1, cons
         len += strlen(new_line->name2);
     }
 
+    new_line->id = (hst->line_end->id + 1 + hst->queue_sz) % INT_MAX;
     new_line->len = len;
     new_line->type = type;
     new_line->bold = bold;
@@ -223,6 +235,8 @@ void line_info_add(ToxWindow *self, const char *timestr, const char *name1, cons
     new_line->timestamp = get_unix_time();
 
     hst->queue[hst->queue_sz++] = new_line;
+
+    return new_line->id;
 }
 
 /* adds a single queue item to hst if possible. only called once per call to line_info_print() */
@@ -237,10 +251,10 @@ static void line_info_check_queue(ToxWindow *self)
     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;
+    hst->line_end->id = line->id;
 
     int y, y2, x, x2;
     getmaxyx(self->window, y2, x2);
@@ -299,7 +313,11 @@ void line_info_print(ToxWindow *self)
 
         switch (type) {
             case OUT_MSG:
+
+            /* fallthrough */
             case OUT_MSG_READ:
+
+            /* fallthrough */
             case IN_MSG:
                 wattron(win, COLOR_PAIR(BLUE));
                 wprintw(win, "%s ", line->timestr);
@@ -316,15 +334,29 @@ void line_info_print(ToxWindow *self)
                 wprintw(win, "%s %s: ", user_settings->line_normal, line->name1);
                 wattroff(win, COLOR_PAIR(nameclr));
 
-                if (line->msg[0] == '>')
-                    wattron(win, COLOR_PAIR(GREEN));
+                char *msg = line->msg;
 
-                wprintw(win, "%s", line->msg);
+                while (msg) {
+                    char *line = strsep(&msg, "\n");
 
-                if (line->msg[0] == '>')
-                    wattroff(win, COLOR_PAIR(GREEN));
+                    if (line[0] == '>')
+                        wattron(win, COLOR_PAIR(GREEN));
+                    else if (line[0] == '<')
+                        wattron(win, COLOR_PAIR(RED));
 
-                if (type == OUT_MSG && timed_out(line->timestamp, get_unix_time(), NOREAD_FLAG_TIMEOUT)) {
+                    wprintw(win, "%s%c", line, msg ? '\n' : '\0');
+
+                    if (line[0] == '>')
+                        wattroff(win, COLOR_PAIR(GREEN));
+                    else if (line[0] == '<')
+                        wattroff(win, COLOR_PAIR(RED));
+
+                    // change the \0 set by strsep back to \n
+                    if (msg)
+                        msg[-1] = '\n';
+                }
+
+                if (type == OUT_MSG && timed_out(line->timestamp, NOREAD_FLAG_TIMEOUT)) {
                     wattron(win, COLOR_PAIR(RED));
                     wprintw(win, " x", line->msg);
                     wattroff(win, COLOR_PAIR(RED));
@@ -339,7 +371,11 @@ void line_info_print(ToxWindow *self)
                 break;
 
             case OUT_ACTION_READ:
+
+            /* fallthrough */
             case OUT_ACTION:
+
+            /* fallthrough */
             case IN_ACTION:
                 wattron(win, COLOR_PAIR(BLUE));
                 wprintw(win, "%s ", line->timestr);
@@ -349,7 +385,7 @@ void line_info_print(ToxWindow *self)
                 wprintw(win, "%s %s %s", user_settings->line_normal, line->name1, line->msg);
                 wattroff(win, COLOR_PAIR(YELLOW));
 
-                if (type == OUT_ACTION && timed_out(line->timestamp, get_unix_time(), NOREAD_FLAG_TIMEOUT)) {
+                if (type == OUT_ACTION && timed_out(line->timestamp, NOREAD_FLAG_TIMEOUT)) {
                     wattron(win, COLOR_PAIR(RED));
                     wprintw(win, " x", line->msg);
                     wattroff(win, COLOR_PAIR(RED));
@@ -525,20 +561,15 @@ bool line_info_onKey(ToxWindow *self, wint_t key)
 
     if (key == user_settings->key_half_page_up) {
         line_info_page_up(self, hst);
-    }
-    else if (key == user_settings->key_half_page_down) {
+    } else if (key == user_settings->key_half_page_down) {
         line_info_page_down(self, hst);
-    }
-    else if (key == user_settings->key_scroll_line_up) {
+    } else if (key == user_settings->key_scroll_line_up) {
         line_info_scroll_up(hst);
-    }
-    else if (key == user_settings->key_scroll_line_down) {
+    } else if (key == user_settings->key_scroll_line_down) {
         line_info_scroll_down(hst);
-    }
-    else if (key == user_settings->key_page_bottom) {
+    } else if (key == user_settings->key_page_bottom) {
         line_info_reset_start(self, hst);
-    }
-    else {
+    } else {
         match = false;
     }
 

src/line_info.h

@@ -50,7 +50,7 @@ struct line_info {
     char name1[TOXIC_MAX_NAME_LENGTH + 1];
     char name2[TOXIC_MAX_NAME_LENGTH + 1];
     char msg[MAX_LINE_INFO_MSG_SIZE];
-    uint64_t timestamp;
+    time_t timestamp;
     uint8_t type;
     uint8_t bold;
     uint8_t colour;
@@ -74,9 +74,13 @@ struct history {
     int queue_sz;
 };
 
-/* creates new line_info line and puts it in the queue. */
-void line_info_add(ToxWindow *self, const char *timestr, const char *name1, const char *name2, uint8_t type,
-                   uint8_t bold, uint8_t colour, const char *msg, ...);
+/* creates new line_info line and puts it in the queue.
+ *
+ * Returns the id of the new line.
+ * Returns -1 on failure.
+ */
+int line_info_add(ToxWindow *self, const char *timestr, const char *name1, const char *name2, uint8_t type,
+                  uint8_t bold, uint8_t colour, const char *msg, ...);
 
 /* Prints a section of history starting at line_start */
 void line_info_print(ToxWindow *self);

src/log.c

@@ -139,11 +139,9 @@ void write_to_log(const char *msg, const char *name, struct chatlog *log, bool e
     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)) {
+    if (timed_out(log->lastwrite, LOG_FLUSH_LIMIT)) {
         fflush(log->file);
-        log->lastwrite = curtime;
+        log->lastwrite = get_unix_time();
     }
 }
 
@@ -155,15 +153,19 @@ void log_disable(struct chatlog *log)
     memset(log, 0, sizeof(struct chatlog));
 }
 
-void log_enable(char *name, const char *selfkey, const char *otherkey, struct chatlog *log, int logtype)
+int log_enable(char *name, const char *selfkey, const char *otherkey, struct chatlog *log, int logtype)
 {
     log->log_on = true;
 
     if (log->file != NULL)
-        return;
+        return 0;
 
-    if (init_logging_session(name, selfkey, otherkey, log, logtype) == -1)
+    if (init_logging_session(name, selfkey, otherkey, log, logtype) == -1) {
         log_disable(log);
+        return -1;
+    }
+
+    return 0;
 }
 
 /* Loads previous history from chat log */
@@ -177,7 +179,7 @@ void load_chat_history(ToxWindow *self, struct chatlog *log)
     if (sz <= 0)
         return;
 
-    char *hstbuf = malloc(sz);
+    char *hstbuf = malloc(sz + 1);
 
     if (hstbuf == NULL)
         exit_toxic_err("failed in load_chat_history", FATALERR_MEMORY);
@@ -194,6 +196,8 @@ void load_chat_history(ToxWindow *self, struct chatlog *log)
         return;
     }
 
+    hstbuf[sz] = '\0';
+
     /* Number of history lines to load: must not be larger than MAX_LINE_INFO_QUEUE - 2 */
     int L = MIN(MAX_LINE_INFO_QUEUE - 2, user_settings->history_size);
     int start, count = 0;
@@ -258,6 +262,7 @@ int rename_logfile(char *src, char *dest, const char *selfkey, const char *other
     return 0;
 
 on_error:
+
     if (log_on)
         log_enable(src, selfkey, otherkey, log, LOG_CHAT);
 

src/log.h

@@ -25,7 +25,7 @@
 
 struct chatlog {
     FILE *file;
-    uint64_t lastwrite;
+    time_t lastwrite;
     char path[MAX_STR_SIZE];
     bool log_on;    /* specific to current chat window */
 };
@@ -39,8 +39,12 @@ enum {
 /* formats/writes line to log file */
 void write_to_log(const char *msg, const char *name, struct chatlog *log, bool event);
 
-/* enables logging for specified log and creates/fetches file if necessary */
-void log_enable(char *name, const char *selfkey, const char *otherkey, struct chatlog *log, int logtype);
+/* enables logging for specified log and creates/fetches file if necessary.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int log_enable(char *name, const char *selfkey, const char *otherkey, struct chatlog *log, int logtype);
 
 /* disables logging for specified log and closes file */
 void log_disable(struct chatlog *log);

src/message_queue.c

@@ -42,8 +42,12 @@ void cqueue_cleanup(struct chat_queue *q)
     free(q);
 }
 
-void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type, uint32_t line_id)
+void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type, int line_id)
 {
+    if (line_id < 0) {
+        return;
+    }
+
     struct cqueue_msg *new_m = malloc(sizeof(struct cqueue_msg));
 
     if (new_m == NULL)
@@ -140,9 +144,7 @@ void cqueue_try_send(ToxWindow *self, Tox *m)
     if (!msg)
         return;
 
-    uint64_t curtime = get_unix_time();
-
-    if (msg->receipt != 0 && !timed_out(msg->last_send_try, curtime, CQUEUE_TRY_SEND_INTERVAL))
+    if (msg->receipt != 0 && !timed_out(msg->last_send_try, CQUEUE_TRY_SEND_INTERVAL))
         return;
 
     uint32_t receipt = 0;
@@ -150,7 +152,7 @@ void cqueue_try_send(ToxWindow *self, Tox *m)
     TOX_MESSAGE_TYPE type = msg->type == OUT_MSG ? TOX_MESSAGE_TYPE_NORMAL : TOX_MESSAGE_TYPE_ACTION;
     receipt = tox_friend_send_message(m, self->num, type, (uint8_t *) msg->message, msg->len, NULL);
 
-    msg->last_send_try = curtime;
+    msg->last_send_try = get_unix_time();
     msg->receipt = receipt;
     return;
 }

src/message_queue.h

@@ -29,7 +29,7 @@ struct cqueue_msg {
     int line_id;
     uint8_t type;
     uint32_t receipt;
-    uint64_t last_send_try;
+    time_t last_send_try;
     struct cqueue_msg *next;
     struct cqueue_msg *prev;
 };
@@ -40,7 +40,7 @@ struct chat_queue {
 };
 
 void cqueue_cleanup(struct chat_queue *q);
-void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type, uint32_t line_id);
+void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type, int line_id);
 
 /* Tries to send the oldest unsent message in queue. */
 void cqueue_try_send(ToxWindow *self, Tox *m);

src/misc_tools.c

@@ -26,6 +26,11 @@
 #include <time.h>
 #include <limits.h>
 #include <dirent.h>
+#if SYSTEM == BSD
+#include <netinet/in.h>
+#include <sys/socket.h>
+#endif /* BSD! */
+#include <arpa/inet.h>
 #include <sys/stat.h>
 
 #include "toxic.h"
@@ -37,8 +42,6 @@
 extern ToxWindow *prompt;
 extern struct user_settings *user_settings;
 
-static uint64_t current_unix_time;
-
 void hst_to_net(uint8_t *num, uint16_t numbytes)
 {
 #ifndef WORDS_BIGENDIAN
@@ -54,28 +57,23 @@ void hst_to_net(uint8_t *num, uint16_t numbytes)
     return;
 }
 
-void update_unix_time(void)
+time_t get_unix_time(void)
 {
-    current_unix_time = (uint64_t) time(NULL);
-}
-
-uint64_t get_unix_time(void)
-{
-    return current_unix_time;
+    return time(NULL);
 }
 
 /* Returns 1 if connection has timed out, 0 otherwise */
-int timed_out(uint64_t timestamp, uint64_t curtime, uint64_t timeout)
+int timed_out(time_t timestamp, time_t timeout)
 {
-    return timestamp + timeout <= curtime;
+    return timestamp + timeout <= get_unix_time();
 }
 
 /* Get the current local time */
 struct tm *get_time(void)
 {
     struct tm *timeinfo;
-    uint64_t t = get_unix_time();
-    timeinfo = localtime((const time_t*) &t);
+    time_t t = get_unix_time();
+    timeinfo = localtime((const time_t *) &t);
     return timeinfo;
 }
 
@@ -92,7 +90,7 @@ void get_time_str(char *buf, int bufsize)
 }
 
 /* Converts seconds to string in format HH:mm:ss; truncates hours and minutes when necessary */
-void get_elapsed_time_str(char *buf, int bufsize, uint64_t secs)
+void get_elapsed_time_str(char *buf, int bufsize, time_t secs)
 {
     if (!secs)
         return;
@@ -109,20 +107,24 @@ void get_elapsed_time_str(char *buf, int bufsize, uint64_t secs)
         snprintf(buf, bufsize, "%ld:%.2ld:%.2ld", hours, minutes, seconds);
 }
 
-char *hex_string_to_bin(const char *hex_string)
+/*
+ * Converts a hexidecimal string of length hex_len to binary format and puts the result in output.
+ * output_size must be exactly half of hex_len.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size_t output_size)
 {
-    size_t len = strlen(hex_string);
-    char *val = malloc(len);
+    if (output_size == 0 || hex_len != output_size * 2)
+        return -1;
 
-    if (val == NULL)
-        exit_toxic_err("failed in hex_string_to_bin", FATALERR_MEMORY);
+    for (size_t i = 0; i < output_size; ++i) {
+        sscanf(hex_string, "%2hhx", &output[i]);
+        hex_string += 2;
+    }
 
-    size_t i;
-
-    for (i = 0; i < len; ++i, hex_string += 2)
-        sscanf(hex_string, "%2hhx", &val[i]);
-
-    return val;
+    return 0;
 }
 
 int hex_string_to_bytes(char *buf, int size, const char *keystr)
@@ -144,12 +146,42 @@ int hex_string_to_bytes(char *buf, int size, const char *keystr)
     return 0;
 }
 
+/* Converts a binary representation of a Tox ID into a string.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_t output_size)
+{
+    if (bin_id_size != TOX_ADDRESS_SIZE || output_size < (TOX_ADDRESS_SIZE * 2 + 1))
+        return -1;
+
+    size_t i;
+
+    for (i = 0; i < TOX_ADDRESS_SIZE; ++i)
+        snprintf(&output[i * 2], output_size - (i * 2), "%02X", bin_id[i] & 0xff);
+
+    return 0;
+}
+
 /* Returns 1 if the string is empty, 0 otherwise */
 int string_is_empty(const char *string)
 {
+    if (!string)
+        return true;
+
     return string[0] == '\0';
 }
 
+/* Returns 1 if the string is empty, 0 otherwise */
+int wstring_is_empty(const wchar_t *string)
+{
+    if (!string)
+        return true;
+
+    return string[0] == L'\0';
+}
+
 /* convert a multibyte string to a wide character string and puts in buf. */
 int mbs_to_wcs_buf(wchar_t *buf, const char *string, size_t n)
 {
@@ -158,7 +190,7 @@ int mbs_to_wcs_buf(wchar_t *buf, const char *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;
@@ -172,7 +204,7 @@ int wcs_to_mbs_buf(char *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;
@@ -199,11 +231,11 @@ int valid_nick(const char *nick)
 
     for (i = 0; nick[i]; ++i) {
         if ((nick[i] == ' ' && nick[i + 1] == ' ')
-            || nick[i] == '/'
-            || nick[i] == '\n'
-            || nick[i] == '\t'
-            || nick[i] == '\v'
-            || nick[i] == '\r')
+                || nick[i] == '/'
+                || nick[i] == '\n'
+                || nick[i] == '\t'
+                || nick[i] == '\v'
+                || nick[i] == '\r')
 
             return 0;
     }
@@ -217,22 +249,24 @@ void filter_str(char *str, size_t len)
     size_t i;
 
     for (i = 0; i < len; ++i) {
-        if (str[i] == '\n' || str[i] == '\r' || str[i] == '\t' || str[i] == '\v')
+        if (str[i] == '\n' || str[i] == '\r' || str[i] == '\t' || str[i] == '\v' || str[i] == '\0')
             str[i] = ' ';
     }
 }
 
-/* gets base file name from path or original file name if no path is supplied */
-void get_file_name(char *namebuf, int bufsize, const char *pathname)
+/* gets base file name from path or original file name if no path is supplied.
+ * Returns the file name length
+ */
+size_t get_file_name(char *namebuf, size_t bufsize, const char *pathname)
 {
-    int idx = strlen(pathname) - 1;
+    int len = strlen(pathname) - 1;
     char *path = strdup(pathname);
 
     if (path == NULL)
         exit_toxic_err("failed in get_file_name", FATALERR_MEMORY);
 
-    while (idx >= 0 && pathname[idx] == '/')
-        path[idx--] = '\0';
+    while (len >= 0 && pathname[len] == '/')
+        path[len--] = '\0';
 
     char *finalname = strdup(path);
 
@@ -249,6 +283,29 @@ void get_file_name(char *namebuf, int bufsize, const char *pathname)
     snprintf(namebuf, bufsize, "%s", finalname);
     free(finalname);
     free(path);
+
+    return strlen(namebuf);
+}
+
+/* Gets the base directory of path and puts it in dir.
+ * dir must have at least as much space as path_len + 1.
+ *
+ * Returns the length of the base directory.
+ */
+size_t get_base_dir(const char *path, size_t path_len, char *dir)
+{
+    if (path_len == 0 || path == NULL)
+        return 0;
+
+    size_t dir_len = char_rfind(path, '/', path_len);
+
+    if (dir_len != 0 && dir_len < path_len)
+        ++dir_len;  /* Leave trailing slash */
+
+    memcpy(dir, path, dir_len);
+    dir[dir_len] = '\0';
+
+    return dir_len;
 }
 
 /* converts str to all lowercase */
@@ -265,51 +322,81 @@ void str_to_lower(char *str)
    Returns nick len */
 size_t get_nick_truncate(Tox *m, char *buf, uint32_t friendnum)
 {
-    size_t len = tox_friend_get_name_size(m, friendnum, NULL);
+    TOX_ERR_FRIEND_QUERY err;
+    size_t len = tox_friend_get_name_size(m, friendnum, &err);
 
-    if (len == 0) {
-        strcpy(buf, UNKNOWN_NAME);
-        len = strlen(UNKNOWN_NAME);
+    if (err != TOX_ERR_FRIEND_QUERY_OK) {
+        goto on_error;
     } else {
-        tox_friend_get_name(m, friendnum, (uint8_t *) buf, NULL);
+        if (!tox_friend_get_name(m, friendnum, (uint8_t *) buf, NULL)) {
+            goto on_error;
+        }
     }
 
     len = MIN(len, TOXIC_MAX_NAME_LENGTH - 1);
     buf[len] = '\0';
     filter_str(buf, len);
     return len;
+
+on_error:
+    strcpy(buf, UNKNOWN_NAME);
+    len = strlen(UNKNOWN_NAME);
+    buf[len] = '\0';
+    return len;
 }
 
 /* same as get_nick_truncate but for groupchats */
-int get_group_nick_truncate(Tox *m, char *buf, int peernum, int groupnum)
+int get_group_nick_truncate(Tox *m, char *buf, uint32_t peernum, uint32_t groupnum)
 {
-    int len = tox_group_peername(m, groupnum, peernum, (uint8_t *) buf);
+    TOX_ERR_CONFERENCE_PEER_QUERY err;
+    size_t len = tox_conference_peer_get_name_size(m, groupnum, peernum, &err);
 
-    if (len == -1) {
-        strcpy(buf, UNKNOWN_NAME);
-        len = strlen(UNKNOWN_NAME);
+    if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
+        goto on_error;
+    } else {
+        if (!tox_conference_peer_get_name(m, groupnum, peernum, (uint8_t *) buf, NULL)) {
+            goto on_error;
+        }
     }
 
     len = MIN(len, TOXIC_MAX_NAME_LENGTH - 1);
     buf[len] = '\0';
     filter_str(buf, len);
     return len;
-}
 
-/* copies data to msg buffer.
-   returns length of msg, which will be no larger than size-1 */
-size_t copy_tox_str(char *msg, size_t size, const char *data, size_t length)
-{
-    size_t len = MIN(length, size - 1);
-    memcpy(msg, data, len);
-    msg[len] = '\0';
+on_error:
+    strcpy(buf, UNKNOWN_NAME);
+    len = strlen(UNKNOWN_NAME);
+    buf[len] = '\0';
     return len;
 }
 
+/* copies data to msg buffer, removing return characters.
+   returns length of msg, which will be no larger than size-1 */
+size_t copy_tox_str(char *msg, size_t size, const char *data, size_t length)
+{
+    size_t i;
+    size_t j = 0;
+
+    for (i = 0; (i < length) && (j < size - 1); ++i) {
+        if (data[i] != '\r') {
+            msg[j++] = data[i];
+        }
+    }
+
+    msg[j] = '\0';
+
+    return j;
+}
+
 /* returns index of the first instance of ch in s starting at idx.
-   returns length of s if char not found */
+   returns length of s if char not found or 0 if s is NULL. */
 int char_find(int idx, const char *s, char ch)
 {
+    if (!s) {
+        return 0;
+    }
+
     int i = idx;
 
     for (i = idx; s[i]; ++i) {
@@ -320,10 +407,14 @@ int char_find(int idx, const char *s, char ch)
     return i;
 }
 
-/* returns index of the last instance of ch in s starting at len
-   returns 0 if char not found (skips 0th index) */
+/* returns index of the last instance of ch in s starting at len.
+   returns 0 if char not found or s is NULL (skips 0th index). */
 int char_rfind(const char *s, char ch, int len)
 {
+    if (!s) {
+        return 0;
+    }
+
     int i = 0;
 
     for (i = len; i > 0; --i) {
@@ -363,7 +454,7 @@ bool file_exists(const char *path)
     return stat(path, &s) == 0;
 }
 
-/* returns file size or 0 on error */
+/* returns file size. If file doesn't exist returns 0. */
 off_t file_size(const char *path)
 {
     struct stat st;
@@ -410,3 +501,36 @@ void set_window_title(ToxWindow *self, const char *title, int len)
 
     snprintf(self->name, sizeof(self->name), "%s", cpy);
 }
+
+/* Return true if address appears to be a valid ipv4 address. */
+bool is_ip4_address(const char *address)
+{
+    struct sockaddr_in s_addr;
+    return inet_pton(AF_INET, address, &(s_addr.sin_addr)) != 0;
+}
+
+/* Return true if address roughly appears to be a valid ipv6 address.
+ *
+ * TODO: Improve this function (inet_pton behaves strangely with ipv6).
+ * for now the only guarantee is that it won't return true if the
+ * address is a domain or ipv4 address, and should only be used if you're
+ * reasonably sure that the address is one of the three (ipv4, ipv6 or a domain).
+ */
+bool is_ip6_address(const char *address)
+{
+    size_t i;
+    size_t num_colons = 0;
+    char ch = 0;
+
+    for (i = 0; (ch = address[i]); ++i) {
+        if (ch == '.') {
+            return false;
+        }
+
+        if (ch == ':') {
+            ++num_colons;
+        }
+    }
+
+    return num_colons > 1 && num_colons < 8;
+}

src/misc_tools.h

@@ -41,30 +41,43 @@
 
 void hst_to_net(uint8_t *num, uint16_t numbytes);
 
-/* convert a hex string to binary */
-char *hex_string_to_bin(const char *hex_string);
+/*
+ * Converts a hexidecimal string of length hex_len to binary format and puts the result in output.
+ * output_size must be exactly half of hex_len.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size_t output_size);
 
 /* convert a hex string to bytes. returns 0 on success, -1 on failure */
 int hex_string_to_bytes(char *buf, int size, const char *keystr);
 
-/* get the current unix time */
-uint64_t get_unix_time(void);
+/* Converts a binary representation of a Tox ID into a string.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_t output_size);
 
-/* Puts the current time in buf in the format of [HH:mm:ss] */
+/* get the current unix time (not thread safe) */
+time_t get_unix_time(void);
+
+/* Puts the current time in buf in the format of [HH:mm:ss] (not thread safe) */
 void get_time_str(char *buf, int bufsize);
 
 /* Converts seconds to string in format HH:mm:ss; truncates hours and minutes when necessary */
-void get_elapsed_time_str(char *buf, int bufsize, uint64_t secs);
+void get_elapsed_time_str(char *buf, int bufsize, time_t secs);
 
-/* get the current local time */
+/* get the current local time (not thread safe) */
 struct tm *get_time(void);
 
-/* 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(const char *string);
 
+/* Same as above but for wide character strings */
+int wstring_is_empty(const wchar_t *string);
+
 /* convert a multibyte string to a wide character string (must provide buffer) */
 int char_to_wcs_buf(wchar_t *buf, const char *string, size_t n);
 
@@ -75,7 +88,7 @@ int wcs_to_mbs_buf(char *buf, const wchar_t *string, size_t n);
 int mbs_to_wcs_buf(wchar_t *buf, const char *string, size_t n);
 
 /* Returns 1 if connection has timed out, 0 otherwise */
-int timed_out(uint64_t timestamp, uint64_t timeout, uint64_t curtime);
+int timed_out(time_t timestamp, time_t timeout);
 
 /* Colours the window tab according to type. Beeps if is_beep is true */
 void alert_window(ToxWindow *self, int type, bool is_beep);
@@ -92,10 +105,18 @@ int qsort_strcasecmp_hlpr(const void *str1, const void *str2);
 int valid_nick(const char *nick);
 
 /* Converts all newline/tab chars to spaces (use for strings that should be contained to a single line) */
-void filter_str(char *str, size_t len);;
+void filter_str(char *str, size_t len);
 
 /* gets base file name from path or original file name if no path is supplied */
-void get_file_name(char *namebuf, int bufsize, const char *pathname);
+size_t get_file_name(char *namebuf, size_t bufsize, const char *pathname);
+
+/* Gets the base directory of path and puts it in dir.
+ * dir must have at least as much space as path_len.
+ *
+ * Returns the length of the base directory on success.
+ * Returns -1 on failure.
+ */
+size_t get_base_dir(const char *path, size_t path_len, char *dir);
 
 /* converts str to all lowercase */
 void str_to_lower(char *str);
@@ -105,18 +126,18 @@ void str_to_lower(char *str);
 size_t get_nick_truncate(Tox *m, char *buf, uint32_t friendnum);
 
 /* same as get_nick_truncate but for groupchats */
-int get_group_nick_truncate(Tox *m, char *buf, int peernum, int groupnum);
+int get_group_nick_truncate(Tox *m, char *buf, uint32_t peernum, uint32_t groupnum);
 
 /* copies data to msg buffer.
    returns length of msg, which will be no larger than size-1 */
 size_t copy_tox_str(char *msg, size_t size, const char *data, size_t length);
 
 /* returns index of the first instance of ch in s starting at idx.
-   returns length of s if char not found */
+   returns length of s if char not found or 0 if s is NULL. */
 int char_find(int idx, const char *s, char ch);
 
-/* returns index of the last instance of ch in s
-   returns 0 if char not found */
+/* returns index of the last instance of ch in s starting at len.
+   returns 0 if char not found or s is NULL (skips 0th index). */
 int char_rfind(const char *s, char ch, int len);
 
 /* Converts bytes to appropriate unit and puts in buf as a string */
@@ -125,7 +146,7 @@ void bytes_convert_str(char *buf, int size, uint64_t bytes);
 /* checks if a file exists. Returns true or false */
 bool file_exists(const char *path);
 
-/* returns file size or 0 on error */
+/* returns file size. If file doesn't exist returns 0. */
 off_t file_size(const char *path);
 
 /* compares the first size bytes of fp and signature.
@@ -137,4 +158,16 @@ int check_file_signature(const char *signature, size_t size, FILE *fp);
 /* sets window title in tab bar. */
 void set_window_title(ToxWindow *self, const char *title, int len);
 
+/* Return true if address appears to be a valid ipv4 address. */
+bool is_ip4_address(const char *address);
+
+/* Return true if address roughly appears to be a valid ipv6 address.
+ *
+ * TODO: Improve this function (inet_pton behaves strangely with ipv6).
+ * for now the only guarantee is that it won't return true if the
+ * address is a domain or ipv4 address, and should only be used if you're
+ * reasonably sure that the address is one of the three (ipv4, ipv6 or a domain).
+ */
+bool is_ip6_address(const char *address);
+
 #endif /* #define MISC_TOOLS_H */

src/name_lookup.c

@@ -0,0 +1,402 @@
+/*  name_lookup.c
+ *
+ *
+ *  Copyright (C) 2015 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/>.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <curl/curl.h>
+
+#include "toxic.h"
+#include "windows.h"
+#include "line_info.h"
+#include "global_commands.h"
+#include "misc_tools.h"
+#include "configdir.h"
+#include "curl_util.h"
+
+extern struct arg_opts arg_opts;
+extern struct Winthread Winthread;
+
+#define NAMESERVER_API_PATH "api"
+#define SERVER_KEY_SIZE 32
+#define MAX_SERVERS 50
+#define MAX_DOMAIN_SIZE 32
+#define MAX_SERVER_LINE MAX_DOMAIN_SIZE + (SERVER_KEY_SIZE * 2) + 3
+
+struct Nameservers {
+    int     lines;
+    char    names[MAX_SERVERS][MAX_DOMAIN_SIZE];
+    char    keys[MAX_SERVERS][SERVER_KEY_SIZE];
+} Nameservers;
+
+static struct thread_data {
+    Tox       *m;
+    ToxWindow *self;
+    char    id_bin[TOX_ADDRESS_SIZE];
+    char    addr[MAX_STR_SIZE];
+    char    msg[MAX_STR_SIZE];
+    bool    disabled;
+    volatile bool busy;
+} t_data;
+
+static struct lookup_thread {
+    pthread_t tid;
+    pthread_attr_t attr;
+} lookup_thread;
+
+static int lookup_error(ToxWindow *self, const char *errmsg, ...)
+{
+    char frmt_msg[MAX_STR_SIZE];
+
+    va_list args;
+    va_start(args, errmsg);
+    vsnprintf(frmt_msg, sizeof(frmt_msg), errmsg, args);
+    va_end(args);
+
+    pthread_mutex_lock(&Winthread.lock);
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "name lookup failed: %s", frmt_msg);
+    pthread_mutex_unlock(&Winthread.lock);
+
+    return -1;
+}
+
+static void kill_lookup_thread(void)
+{
+    memset(&t_data, 0, sizeof(struct thread_data));
+    pthread_attr_destroy(&lookup_thread.attr);
+    pthread_exit(NULL);
+}
+
+/* Attempts to load the nameserver list pointed at by path into the Nameservers structure.
+ *
+ * Returns 0 on success.
+ * -1 is reserved.
+ * Returns -2 if the supplied path does not exist.
+ * Returns -3 if the list does not contain any valid entries.
+ */
+static int load_nameserver_list(const char *path)
+{
+    FILE *fp = fopen(path, "r");
+
+    if (fp == NULL)
+        return -2;
+
+    char line[MAX_SERVER_LINE];
+
+    while (fgets(line, sizeof(line), fp) && Nameservers.lines < MAX_SERVERS) {
+        int linelen = strlen(line);
+
+        if (linelen < SERVER_KEY_SIZE * 2 + 5)
+            continue;
+
+        if (line[linelen - 1] == '\n')
+            line[--linelen] = '\0';
+
+        const char *name = strtok(line, " ");
+        const char *keystr = strtok(NULL, " ");
+
+        if (name == NULL || keystr == NULL)
+            continue;
+
+        if (strlen(keystr) != SERVER_KEY_SIZE * 2)
+            continue;
+
+        snprintf(Nameservers.names[Nameservers.lines], sizeof(Nameservers.names[Nameservers.lines]), "%s", name);
+        int res = hex_string_to_bytes(Nameservers.keys[Nameservers.lines], SERVER_KEY_SIZE, keystr);
+
+        if (res == -1)
+            continue;
+
+        ++Nameservers.lines;
+    }
+
+    fclose(fp);
+
+    if (Nameservers.lines < 1)
+        return -3;
+
+    return 0;
+}
+
+/* Takes address addr in the form "username@domain", puts the username in namebuf,
+ * and the domain in dombuf.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure
+ */
+static int parse_addr(const char *addr, char *namebuf, size_t namebuf_sz, char *dombuf, size_t dombuf_sz)
+{
+    if (strlen(addr) >= (MAX_STR_SIZE - strlen(NAMESERVER_API_PATH)))
+        return -1;
+
+    char tmpaddr[MAX_STR_SIZE];
+    char *tmpname = NULL;
+    char *tmpdom = NULL;
+
+    snprintf(tmpaddr, sizeof(tmpaddr), "%s", addr);
+    tmpname = strtok(tmpaddr, "@");
+    tmpdom = strtok(NULL, "");
+
+    if (tmpname == NULL || tmpdom == NULL)
+        return -1;
+
+    str_to_lower(tmpdom);
+    snprintf(namebuf, namebuf_sz, "%s", tmpname);
+    snprintf(dombuf, dombuf_sz, "%s", tmpdom);
+
+    return 0;
+}
+
+/* matches input domain name with domains in list and obtains key.
+ * Turns out_domain into the full domain we need to make a POST request.
+ *
+ * Return true on match.
+ * Returns false on no match.
+ */
+static bool get_domain_match(char *pubkey, char *out_domain, size_t out_domain_size, const char *inputdomain)
+{
+    int i;
+
+    for (i = 0; i < Nameservers.lines; ++i) {
+        if (strcmp(Nameservers.names[i], inputdomain) == 0) {
+            memcpy(pubkey, Nameservers.keys[i], SERVER_KEY_SIZE);
+            snprintf(out_domain, out_domain_size, "https://%s/%s", Nameservers.names[i], NAMESERVER_API_PATH);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/* Converts Tox ID string contained in recv_data to binary format and puts it in thread's ID buffer.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+#define ID_PREFIX "\"tox_id\": \""
+static int process_response(struct Recv_Curl_Data *recv_data)
+{
+    size_t prefix_size = strlen(ID_PREFIX);
+
+    if (recv_data->length < TOX_ADDRESS_SIZE * 2 + prefix_size)
+        return -1;
+
+    const char *IDstart = strstr(recv_data->data, ID_PREFIX);
+
+    if (IDstart == NULL)
+        return -1;
+
+    if (strlen(IDstart) < TOX_ADDRESS_SIZE * 2 + prefix_size)
+        return -1;
+
+    char ID_string[TOX_ADDRESS_SIZE * 2 + 1];
+    memcpy(ID_string, IDstart + prefix_size, TOX_ADDRESS_SIZE * 2);
+    ID_string[TOX_ADDRESS_SIZE * 2] = 0;
+
+    if (hex_string_to_bin(ID_string, strlen(ID_string), t_data.id_bin, sizeof(t_data.id_bin)) == -1)
+        return -1;
+
+    return 0;
+}
+
+void *lookup_thread_func(void *data)
+{
+    ToxWindow *self = t_data.self;
+
+    char input_domain[MAX_STR_SIZE];
+    char name[MAX_STR_SIZE];
+
+    if (parse_addr(t_data.addr, name, sizeof(name), input_domain, sizeof(input_domain)) == -1) {
+        lookup_error(self, "Input must be a 76 character Tox ID or an address in the form: username@domain");
+        kill_lookup_thread();
+    }
+
+    char nameserver_key[SERVER_KEY_SIZE];
+    char real_domain[MAX_DOMAIN_SIZE];
+
+    if (!get_domain_match(nameserver_key, real_domain, sizeof(real_domain), input_domain)) {
+        if (!strcasecmp(input_domain, "utox.org"))
+            lookup_error(self, "utox.org uses deprecated DNS-based lookups and is no longer supported by Toxic.");
+        else
+            lookup_error(self, "Name server domain not found.");
+
+        kill_lookup_thread();
+    }
+
+    CURL *c_handle = curl_easy_init();
+
+    if (!c_handle) {
+        lookup_error(self, "curl handler error");
+        kill_lookup_thread();
+    }
+
+    struct Recv_Curl_Data recv_data;
+
+    memset(&recv_data, 0, sizeof(struct Recv_Curl_Data));
+
+    char post_data[MAX_STR_SIZE];
+
+    snprintf(post_data, sizeof(post_data), "{\"action\": 3, \"name\": \"%s\"}", name);
+
+    struct curl_slist *headers = NULL;
+
+    headers = curl_slist_append(headers, "Content-Type: application/json");
+
+    headers = curl_slist_append(headers, "charsets: utf-8");
+
+    curl_easy_setopt(c_handle, CURLOPT_HTTPHEADER, headers);
+
+    curl_easy_setopt(c_handle, CURLOPT_URL, real_domain);
+
+    curl_easy_setopt(c_handle, CURLOPT_WRITEFUNCTION, curl_cb_write_data);
+
+    curl_easy_setopt(c_handle, CURLOPT_WRITEDATA, &recv_data);
+
+    curl_easy_setopt(c_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
+
+    curl_easy_setopt(c_handle, CURLOPT_POSTFIELDS, post_data);
+
+    int proxy_ret = set_curl_proxy(c_handle, arg_opts.proxy_address, arg_opts.proxy_port, arg_opts.proxy_type);
+
+    if (proxy_ret != 0) {
+        lookup_error(self, "Failed to set proxy (error %d)\n");
+        goto on_exit;
+    }
+
+    int ret = curl_easy_setopt(c_handle, CURLOPT_USE_SSL, CURLUSESSL_ALL);
+
+    if (ret != CURLE_OK) {
+        lookup_error(self, "TLS could not be enabled (libcurl error %d)", ret);
+        goto on_exit;
+    }
+
+    ret = curl_easy_setopt(c_handle, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
+
+    if (ret != CURLE_OK) {
+        lookup_error(self, "TLSv1.2 could not be set (libcurl error %d)", ret);
+        goto on_exit;
+    }
+
+    ret = curl_easy_setopt(c_handle, CURLOPT_SSL_CIPHER_LIST, TLS_CIPHER_SUITE_LIST);
+
+    if (ret != CURLE_OK) {
+        lookup_error(self, "Failed to set TLS cipher list (libcurl error %d)", ret);
+        goto on_exit;
+    }
+
+    ret = curl_easy_perform(c_handle);
+
+    if (ret != CURLE_OK) {
+        /* If system doesn't support any of the specified ciphers suites, fall back to default */
+        if (ret == CURLE_SSL_CIPHER) {
+            curl_easy_setopt(c_handle, CURLOPT_SSL_CIPHER_LIST, NULL);
+            ret = curl_easy_perform(c_handle);
+        }
+
+        if (ret != CURLE_OK) {
+            lookup_error(self, "HTTPS lookup error (libcurl error %d)", ret);
+            goto on_exit;
+        }
+    }
+
+    if (process_response(&recv_data) == -1) {
+        lookup_error(self, "Bad response.");
+        goto on_exit;
+    }
+
+    pthread_mutex_lock(&Winthread.lock);
+    cmd_add_helper(self, t_data.m, t_data.id_bin, t_data.msg);
+    pthread_mutex_unlock(&Winthread.lock);
+
+on_exit:
+    curl_slist_free_all(headers);
+    curl_easy_cleanup(c_handle);
+    kill_lookup_thread();
+
+    return 0;
+}
+
+void name_lookup(ToxWindow *self, Tox *m, const char *id_bin, const char *addr, const char *message)
+{
+    if (t_data.disabled) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "name lookups are disabled.");
+        return;
+    }
+
+    if (t_data.busy) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Please wait for previous name lookup to finish.");
+        return;
+    }
+
+    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", message);
+    t_data.self = self;
+    t_data.m = m;
+    t_data.busy = true;
+
+    if (pthread_attr_init(&lookup_thread.attr) != 0) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, "Error: lookup thread attr failed to init");
+        memset(&t_data, 0, sizeof(struct thread_data));
+        return;
+    }
+
+    if (pthread_attr_setdetachstate(&lookup_thread.attr, PTHREAD_CREATE_DETACHED) != 0) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, "Error: lookup thread attr failed to set");
+        pthread_attr_destroy(&lookup_thread.attr);
+        memset(&t_data, 0, sizeof(struct thread_data));
+        return;
+    }
+
+    if (pthread_create(&lookup_thread.tid, &lookup_thread.attr, lookup_thread_func, NULL) != 0) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, RED, "Error: lookup thread failed to init");
+        pthread_attr_destroy(&lookup_thread.attr);
+        memset(&t_data, 0, sizeof(struct thread_data));
+        return;
+    }
+}
+
+/* Initializes http based name lookups. Note: This function must be called only once before additional
+ * threads are spawned.
+ *
+ * Returns 0 on success.
+ * Returns -1 if curl failed to init.
+ * Returns -2 if the nameserver list cannot be found.
+ * Returns -3 if the nameserver list does not contain any valid entries.
+ */
+int name_lookup_init(int curl_init_status)
+{
+    if (curl_init_status != 0) {
+        t_data.disabled = true;
+        return -1;
+    }
+
+    const char *path = arg_opts.nameserver_path[0] ? arg_opts.nameserver_path : PACKAGE_DATADIR "/nameservers";
+    int ret = load_nameserver_list(path);
+
+    if (ret != 0) {
+        t_data.disabled = true;
+        return ret;
+    }
+
+    return 0;
+}

src/name_lookup.h

@@ -1,7 +1,7 @@
-/*  dns.c
+/*  name_lookup.h
  *
  *
- *  Copyright (C) 2014 Toxic All Rights Reserved.
+ *  Copyright (C) 2015 Toxic All Rights Reserved.
  *
  *  This file is part of Toxic.
  *
@@ -20,13 +20,17 @@
  *
  */
 
-/* Does DNS lookup for addr and puts resulting tox id in id_bin.
-   Return 0 on success, -1 on failure. */
+#ifndef NAME_LOOKUP
+#define NAME_LOOKUP
 
-#ifndef DNS_H
-#define DNS_H
+/* Initializes http based name lookups. Note: This function must be called only once before additional
+ * threads are spawned.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int name_lookup_init(int curl_init_status);
 
-/* creates new thread for dns3 lookup. Only allows one lookup at a time. */
-void dns3_lookup(ToxWindow *self, Tox *m, const char *id_bin, const char *addr, const char *msg);
+int name_lookup(ToxWindow *self, Tox *m, const char *id_bin, const char *addr, const char *message);
 
-#endif /* #define DNS_H */
+#endif /* NAME_LOOKUP */

src/notify.c

@@ -31,31 +31,31 @@
 #include <sys/stat.h>
 
 #include "notify.h"
-#include "device.h"
+#include "audio_device.h"
 #include "settings.h"
 #include "line_info.h"
 #include "misc_tools.h"
 #include "xtra.h"
 
 #if defined(AUDIO) || defined(SOUND_NOTIFY)
-    #ifdef __APPLE__
-        #include <OpenAL/al.h>
-        #include <OpenAL/alc.h>
-    #else
-        #include <AL/al.h>
-        #include <AL/alc.h>
-        /* compatibility with older versions of OpenAL */
-        #ifndef ALC_ALL_DEVICES_SPECIFIER
-            #include <AL/alext.h>
-        #endif
-    #endif
-    #ifdef SOUND_NOTIFY
-        #include <AL/alut.h> /* freealut packet */
-    #endif
+#ifdef __APPLE__
+#include <OpenAL/al.h>
+#include <OpenAL/alc.h>
+#else
+#include <AL/al.h>
+#include <AL/alc.h>
+/* compatibility with older versions of OpenAL */
+#ifndef ALC_ALL_DEVICES_SPECIFIER
+#include <AL/alext.h>
+#endif
+#endif
+#ifdef SOUND_NOTIFY
+#include <AL/alut.h> /* freealut packet */
+#endif
 #endif /* AUDIO */
 
 #ifdef BOX_NOTIFY
-    #include <libnotify/notify.h>
+#include <libnotify/notify.h>
 #endif
 
 #define MAX_BOX_MSG_LEN 127
@@ -75,7 +75,7 @@ struct Control {
 
 #ifdef SOUND_NOTIFY
     uint32_t device_idx; /* index of output device */
-    char* sounds[SOUNDS_SIZE];
+    char *sounds[SOUNDS_SIZE];
 #endif /* SOUND_NOTIFY */
 } Control = {0};
 
@@ -88,9 +88,9 @@ struct _ActiveNotifications {
     bool active;
     int *id_indicator;
 #ifdef BOX_NOTIFY
-    NotifyNotification* box;
+    NotifyNotification *box;
     char messages[MAX_BOX_MSG_LEN + 1][MAX_BOX_MSG_LEN + 1];
-    char title[24];
+    char title[64];
     size_t size;
     time_t n_timeout;
 #endif
@@ -117,9 +117,12 @@ static void tab_notify(ToxWindow *self, uint64_t flags)
 
 static bool notifications_are_disabled(uint64_t flags)
 {
-    bool res = flags & NT_RESTOL && Control.cooldown > get_unix_time();
+    if (user_settings->alerts != ALERTS_ENABLED)
+        return true;
+
+    bool res = (flags & NT_RESTOL) && (Control.cooldown > get_unix_time());
 #ifdef X11
-    return res || (flags & NT_NOFOCUS && is_focused());
+    return res || ((flags & NT_NOFOCUS) && is_focused());
 #else
     return res;
 #endif
@@ -153,44 +156,49 @@ bool is_playing(int source)
 static bool device_opened = false;
 time_t last_opened_update = 0;
 
-bool m_open_device()
+/* Opens primary device. Returns true on succe*/
+void m_open_device()
 {
     last_opened_update = get_unix_time();
 
-    if (device_opened) return true;
+    if (device_opened) return;
 
     /* Blah error check */
     open_primary_device(output, &Control.device_idx, 48000, 20, 1);
 
-    return (device_opened = true);
+    device_opened = true;
 }
 
-bool m_close_device()
+void m_close_device()
 {
-    if (!device_opened) return true;
+    if (!device_opened) return;
 
     close_device(output, Control.device_idx);
 
-    return !(device_opened = false);
+    device_opened = false;
 }
 
 /* Terminate all sounds but wait for them to finish first */
 void graceful_clear()
 {
-    int i;
     control_lock();
+
     while (1) {
+        int i;
+
         for (i = 0; i < ACTIVE_NOTIFS_MAX; i ++) {
             if (actives[i].active) {
-            #ifdef BOX_NOTIFY
+#ifdef BOX_NOTIFY
+
                 if (actives[i].box) {
-                    GError* ignore;
+                    GError *ignore;
                     notify_notification_close(actives[i].box, &ignore);
                     actives[i].box = NULL;
                 }
-            #endif
 
-                if(actives[i].id_indicator)
+#endif
+
+                if (actives[i].id_indicator)
                     *actives[i].id_indicator = -1;    /* reset indicator value */
 
                 if ( actives[i].looping ) {
@@ -211,76 +219,90 @@ void graceful_clear()
 
         usleep(1000);
     }
+
+    control_unlock();
 }
 
-void* do_playing(void* _p)
+void *do_playing(void *_p)
 {
     (void)_p;
-    int i;
 
-    bool has_looping = false;
-
-    while(Control.poll_active) {
+    while (true) {
         control_lock();
 
+        if (!Control.poll_active) {
+            control_unlock();
+            break;
+        }
+
+        bool has_looping = false;
+        bool test_active_notify = false;
+        int i;
 
         for (i = 0; i < ACTIVE_NOTIFS_MAX; i ++) {
 
             if (actives[i].looping) has_looping = true;
 
-            if (actives[i].active && !actives[i].looping
-                #ifdef BOX_NOTIFY
-                    && !actives[i].box
-                #endif
-            ) {
-                if(actives[i].id_indicator)
+            test_active_notify = actives[i].active && !actives[i].looping;
+#ifdef BOX_NOTIFY
+            test_active_notify = test_active_notify && !actives[i].box;
+#endif
+
+            if (test_active_notify) {
+                if (actives[i].id_indicator)
                     *actives[i].id_indicator = -1;    /* reset indicator value */
 
                 if (!is_playing(actives[i].source)) {
-                /* Close */
+                    /* Close */
                     alSourceStop(actives[i].source);
                     alDeleteSources(1, &actives[i].source);
                     alDeleteBuffers(1, &actives[i].buffer);
                     memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
                 }
             }
-        #ifdef BOX_NOTIFY
-            else if (actives[i].box && get_unix_time() >= actives[i].n_timeout)
-            {
-                GError* ignore;
+
+#ifdef BOX_NOTIFY
+            else if (actives[i].box && time(NULL) >= actives[i].n_timeout) {
+                GError *ignore;
                 notify_notification_close(actives[i].box, &ignore);
                 actives[i].box = NULL;
-                if(actives[i].id_indicator)
+
+                if (actives[i].id_indicator)
                     *actives[i].id_indicator = -1;    /* reset indicator value */
 
                 if (!actives[i].looping && !is_playing(actives[i].source)) {
-                /* stop source if not looping or playing, just terminate box */
+                    /* stop source if not looping or playing, just terminate box */
                     alSourceStop(actives[i].source);
                     alDeleteSources(1, &actives[i].source);
                     alDeleteBuffers(1, &actives[i].buffer);
                     memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
                 }
             }
-        #endif
+
+#endif
         }
 
         /* device is opened and no activity in under DEVICE_COOLDOWN time, close device*/
         if (device_opened && !has_looping &&
-           (get_unix_time() - last_opened_update) > DEVICE_COOLDOWN) {
+                (time(NULL) - last_opened_update) > DEVICE_COOLDOWN) {
             m_close_device();
         }
+
         has_looping = false;
 
         control_unlock();
         usleep(10000);
     }
+
     pthread_exit(NULL);
 }
 
 int play_source(uint32_t source, uint32_t buffer, bool looping)
 {
     int i = 0;
+
     for (; i < ACTIVE_NOTIFS_MAX && actives[i].active; i ++);
+
     if ( i == ACTIVE_NOTIFS_MAX ) {
         return -1; /* Full */
     }
@@ -296,27 +318,37 @@ int play_source(uint32_t source, uint32_t buffer, bool looping)
 }
 
 #elif BOX_NOTIFY
-void* do_playing(void* _p)
+void *do_playing(void *_p)
 {
     (void)_p;
-    int i;
-    while(Control.poll_active) {
+
+    while (true) {
         control_lock();
+
+        if (!Control.poll_active) {
+            control_unlock();
+            break;
+        }
+
+        int i;
+
         for (i = 0; i < ACTIVE_NOTIFS_MAX; i ++) {
-            if (actives[i].box && get_unix_time() >= actives[i].n_timeout)
-            {
-                GError* ignore;
+            if (actives[i].box && time(NULL) >= actives[i].n_timeout) {
+                GError *ignore;
                 notify_notification_close(actives[i].box, &ignore);
                 actives[i].box = NULL;
-                if(actives[i].id_indicator)
+
+                if (actives[i].id_indicator)
                     *actives[i].id_indicator = -1;    /* reset indicator value */
 
                 memset(&actives[i], 0, sizeof(struct _ActiveNotifications));
             }
         }
+
         control_unlock();
         usleep(10000);
     }
+
     pthread_exit(NULL);
 }
 
@@ -327,7 +359,7 @@ void graceful_clear()
 
     for (i = 0; i < ACTIVE_NOTIFS_MAX; i ++) {
         if (actives[i].box) {
-            GError* ignore;
+            GError *ignore;
             notify_notification_close(actives[i].box, &ignore);
             actives[i].box = NULL;
         }
@@ -358,19 +390,21 @@ int init_notify(int login_cooldown, int notification_timeout)
 #endif /* SOUND_NOTIFY */
 
 #if defined(SOUND_NOTIFY) || defined(BOX_NOTIFY)
+
     if (pthread_mutex_init(Control.poll_mutex, NULL) != 0)
         return -1;
 
+    Control.poll_active = 1;
     pthread_t thread;
 
     if (pthread_create(&thread, NULL, do_playing, NULL) != 0 || pthread_detach(thread) != 0 ) {
         pthread_mutex_destroy(Control.poll_mutex);
+        Control.poll_active = 0;
         return -1;
     }
 
-    Control.poll_active = 1;
 #endif
-    Control.cooldown = get_unix_time() + login_cooldown;
+    Control.cooldown = time(NULL) + login_cooldown;
 
 
 #ifdef BOX_NOTIFY
@@ -383,15 +417,24 @@ int init_notify(int login_cooldown, int notification_timeout)
 void terminate_notify()
 {
 #if defined(SOUND_NOTIFY) || defined(BOX_NOTIFY)
-    if ( !Control.poll_active ) return;
+    control_lock();
+
+    if ( !Control.poll_active ) {
+        control_unlock();
+        return;
+    }
+
     Control.poll_active = 0;
+    control_unlock();
 
     graceful_clear();
 #endif
 
 #ifdef SOUND_NOTIFY
     int i = 0;
+
     for (; i < SOUNDS_SIZE; i ++) free(Control.sounds[i]);
+
     alutExit();
 #endif /* SOUND_NOTIFY */
 
@@ -401,7 +444,7 @@ void terminate_notify()
 }
 
 #ifdef SOUND_NOTIFY
-int set_sound(Notification sound, const char* value)
+int set_sound(Notification sound, const char *value)
 {
     if (sound == silent) return 0;
 
@@ -429,10 +472,11 @@ int play_sound_internal(Notification what, bool loop)
     alSourcei(source, AL_LOOPING, loop);
 
     int rc = play_source(source, buffer, loop);
+
     if (rc < 0) {
         alSourceStop(source);
         alDeleteSources(1, &source);
-        alDeleteBuffers(1,&buffer);
+        alDeleteBuffers(1, &buffer);
         return -1;
     }
 
@@ -444,7 +488,8 @@ int play_notify_sound(Notification notif, uint64_t flags)
     int rc = -1;
 
     if (flags & NT_BEEP) beep();
-    else if (notif != silent) {
+
+    if (notif != silent) {
         if ( !Control.poll_active || !Control.sounds[notif] )
             return -1;
 
@@ -459,17 +504,21 @@ void stop_sound(int id)
 {
     if (id >= 0 && id < ACTIVE_NOTIFS_MAX && actives[id].looping && actives[id].active ) {
 #ifdef BOX_NOTIFY
+
         if (actives[id].box) {
-            GError* ignore;
+            GError *ignore;
             notify_notification_close(actives[id].box, &ignore);
         }
+
 #endif
+
         if (actives[id].id_indicator)
             *actives[id].id_indicator = -1;
+
 //         alSourcei(actives[id].source, AL_LOOPING, false);
         alSourceStop(actives[id].source);
         alDeleteSources(1, &actives[id].source);
-        alDeleteBuffers(1,&actives[id].buffer);
+        alDeleteBuffers(1, &actives[id].buffer);
         memset(&actives[id], 0, sizeof(struct _ActiveNotifications));
     }
 }
@@ -480,6 +529,7 @@ static int m_play_sound(Notification notif, uint64_t flags)
 #ifdef SOUND_NOTIFY
     return play_notify_sound(notif, flags);
 #else
+
     if (notif != silent)
         beep();
 
@@ -488,12 +538,12 @@ static int m_play_sound(Notification notif, uint64_t flags)
 }
 
 #ifdef BOX_NOTIFY
-void m_notify_action(NotifyNotification *box, char *action, void* data)
+void m_notify_action(NotifyNotification *box, char *action, void *data)
 {
 }
 #endif
 
-int sound_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indicator)
+int sound_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indicator)
 {
     tab_notify(self, flags);
 
@@ -503,7 +553,7 @@ int sound_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_in
     int id = -1;
     control_lock();
 
-    if (self && (!self->stb || self->stb->status != TOX_USER_STATUS_BUSY) && user_settings->alerts == ALERTS_ENABLED)
+    if (self && (!self->stb || self->stb->status != TOX_USER_STATUS_BUSY))
         id = m_play_sound(notif, flags);
     else if (flags & NT_ALWAYS)
         id = m_play_sound(notif, flags);
@@ -512,6 +562,7 @@ int sound_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_in
 
     if (id == -1) {
         for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].box; id++);
+
         if ( id == ACTIVE_NOTIFS_MAX ) {
             control_unlock();
             return -1; /* Full */
@@ -530,7 +581,7 @@ int sound_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_in
     return id;
 }
 
-int sound_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id)
+int sound_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id)
 {
     tab_notify(self, flags);
 
@@ -538,6 +589,7 @@ int sound_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id)
         return -1;
 
     if (id < 0 || id >= ACTIVE_NOTIFS_MAX) return -1;
+
 #ifdef SOUND_NOTIFY
     control_lock();
 
@@ -550,8 +602,7 @@ int sound_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id)
 
     alSourceStop(actives[id].source);
     alDeleteSources(1, &actives[id].source);
-    alDeleteBuffers(1,&actives[id].buffer);
-
+    alDeleteBuffers(1, &actives[id].buffer);
 
     alGenSources(1, &actives[id].source);
     alGenBuffers(1, &actives[id].buffer);
@@ -565,6 +616,7 @@ int sound_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id)
 
     return id;
 #else
+
     if (notif != silent)
         beep();
 
@@ -572,7 +624,8 @@ int sound_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id)
 #endif /* SOUND_NOTIFY */
 }
 
-int box_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indicator, const char* title, const char* format, ...)
+int box_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indicator, const char *title,
+               const char *format, ...)
 {
     if (notifications_are_disabled(flags)) {
         tab_notify(self, flags);
@@ -586,9 +639,11 @@ int box_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indi
     control_lock();
 
 #ifdef SOUND_NOTIFY
+
     if (id == -1) { /* Could not play */
 
         for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].active; id ++);
+
         if ( id == ACTIVE_NOTIFS_MAX ) {
             control_unlock();
             return -1; /* Full */
@@ -596,14 +651,23 @@ int box_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indi
 
         actives[id].active = 1;
         actives[id].id_indicator = id_indicator;
+
         if (id_indicator) *id_indicator = id;
     }
-#endif
 
-    strncpy(actives[id].title, title, 24);
+#else
+
+    if (id == -1)
+        return -1;
+
+#endif    /* SOUND_NOTIFY */
+
+    snprintf(actives[id].title, sizeof(actives[id].title), "%s", title);
+
     if (strlen(title) > 23) strcpy(actives[id].title + 20, "...");
 
-    va_list __ARGS__; va_start (__ARGS__, format);
+    va_list __ARGS__;
+    va_start (__ARGS__, format);
     vsnprintf (actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
     va_end (__ARGS__);
 
@@ -623,10 +687,10 @@ int box_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indi
     return id;
 #else
     return sound_notify(self, notif, flags, id_indicator);
-#endif
+#endif   /* BOX_NOTIFY */
 }
 
-int box_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id, const char* format, ...)
+int box_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id, const char *format, ...)
 {
     if (notifications_are_disabled(flags)) {
         tab_notify(self, flags);
@@ -645,7 +709,8 @@ int box_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id, con
         return -1;
     }
 
-    va_list __ARGS__; va_start (__ARGS__, format);
+    va_list __ARGS__;
+    va_start (__ARGS__, format);
     vsnprintf (actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
     va_end (__ARGS__);
 
@@ -658,7 +723,8 @@ int box_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id, con
     char formated[128 * 129] = {'\0'};
 
     int i = 0;
-    for (; i <actives[id].size; i ++) {
+
+    for (; i < actives[id].size; i ++) {
         strcat(formated, actives[id].messages[i]);
         strcat(formated, "\n");
     }
@@ -676,7 +742,7 @@ int box_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id, con
 #endif
 }
 
-int box_silent_notify(ToxWindow* self, uint64_t flags, int* id_indicator, const char* title, const char* format, ...)
+int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const char *title, const char *format, ...)
 {
     tab_notify(self, flags);
 
@@ -688,7 +754,9 @@ int box_silent_notify(ToxWindow* self, uint64_t flags, int* id_indicator, const
     control_lock();
 
     int id;
+
     for (id = 0; id < ACTIVE_NOTIFS_MAX && actives[id].active; id ++);
+
     if ( id == ACTIVE_NOTIFS_MAX ) {
         control_unlock();
         return -1; /* Full */
@@ -699,10 +767,12 @@ int box_silent_notify(ToxWindow* self, uint64_t flags, int* id_indicator, const
         *id_indicator = id;
     }
 
-    strncpy(actives[id].title, title, 24);
+    snprintf(actives[id].title, sizeof(actives[id].title), "%s", title);
+
     if (strlen(title) > 23) strcpy(actives[id].title + 20, "...");
 
-    va_list __ARGS__; va_start (__ARGS__, format);
+    va_list __ARGS__;
+    va_start (__ARGS__, format);
     vsnprintf (actives[id].messages[0], MAX_BOX_MSG_LEN, format, __ARGS__);
     va_end (__ARGS__);
 
@@ -726,7 +796,7 @@ int box_silent_notify(ToxWindow* self, uint64_t flags, int* id_indicator, const
 #endif
 }
 
-int box_silent_notify2(ToxWindow* self, uint64_t flags, int id, const char* format, ...)
+int box_silent_notify2(ToxWindow *self, uint64_t flags, int id, const char *format, ...)
 {
     tab_notify(self, flags);
 
@@ -742,7 +812,8 @@ int box_silent_notify2(ToxWindow* self, uint64_t flags, int id, const char* form
     }
 
 
-    va_list __ARGS__; va_start (__ARGS__, format);
+    va_list __ARGS__;
+    va_start (__ARGS__, format);
     vsnprintf (actives[id].messages[actives[id].size], MAX_BOX_MSG_LEN, format, __ARGS__);
     va_end (__ARGS__);
 
@@ -755,7 +826,8 @@ int box_silent_notify2(ToxWindow* self, uint64_t flags, int id, const char* form
     char formated[128 * 129] = {'\0'};
 
     int i = 0;
-    for (; i <actives[id].size; i ++) {
+
+    for (; i < actives[id].size; i ++) {
         strcat(formated, actives[id].messages[i]);
         strcat(formated, "\n");
     }

src/notify.h

@@ -26,8 +26,7 @@
 #include <inttypes.h>
 #include "windows.h"
 
-typedef enum _Notification
-{
+typedef enum _Notification {
     silent = -1,
     notif_error,
     self_log_in,
@@ -63,18 +62,19 @@ typedef enum _Flags {
 int init_notify(int login_cooldown, int notification_timeout);
 void terminate_notify();
 
-int sound_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indicator);
-int sound_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id);
+int sound_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indicator);
+int sound_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id);
 
 void stop_sound(int id);
 
-int box_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indicator, const char* title, const char* format, ...);
-int box_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id, const char* format, ...);
-int box_silent_notify(ToxWindow* self, uint64_t flags, int* id_indicator, const char* title, const char* format, ...);
-int box_silent_notify2(ToxWindow* self, uint64_t flags, int id, const char* format, ...);
+int box_notify(ToxWindow *self, Notification notif, uint64_t flags, int *id_indicator, const char *title,
+               const char *format, ...);
+int box_notify2(ToxWindow *self, Notification notif, uint64_t flags, int id, const char *format, ...);
+int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const char *title, const char *format, ...);
+int box_silent_notify2(ToxWindow *self, uint64_t flags, int id, const char *format, ...);
 
 #ifdef SOUND_NOTIFY
-int set_sound(Notification sound, const char* value);
+int set_sound(Notification sound, const char *value);
 #endif /* SOUND_NOTIFY */
 
 #endif /* NOTIFY_H */

src/osx_video.h

@@ -0,0 +1,57 @@
+/*  osx_video.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 OSX_VIDEO_H
+#define OSX_VIDEO_H
+
+#include <netinet/in.h>
+
+#ifdef __OBJC__
+#import <Foundation/Foundation.h>
+#import <AVFoundation/AVFoundation.h>
+#endif /* __OBJC__ */
+
+#define RELEASE_CHK(func, obj) if ((obj))\
+    func((obj));
+
+void bgrtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t *rgb, uint16_t width, uint16_t height);
+
+#ifdef __OBJC__
+@interface OSXVideo :
+    NSObject <AVCaptureVideoDataOutputSampleBufferDelegate>
+- (instancetype)initWithDeviceNames:
+    (char **)device_names AmtDevices:
+    (int *)size;
+@end
+#endif /* __OBJC__ */
+
+int osx_video_init(char **device_names, int *size);
+void osx_video_release();
+/* Start device */
+int osx_video_open_device(uint32_t selection, uint16_t *width, uint16_t *height);
+/* Stop device */
+void osx_video_close_device(uint32_t device_idx);
+/* Read data from device */
+int osx_video_read_device(uint8_t *y, uint8_t *u, uint8_t *v, uint16_t *width, uint16_t *height);
+
+
+#endif /* OSX_VIDEO_H */

src/osx_video.m

@@ -0,0 +1,342 @@
+/*  osx_video.m
+ *
+ *
+ *  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 __OBJC__
+#include "osx_video.h"
+
+#import <Foundation/Foundation.h>
+#import <AVFoundation/AVFoundation.h>
+
+#include "line_info.h"
+#include "settings.h"
+
+#include <errno.h>
+
+#include <stdbool.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <assert.h>
+
+/*
+ * Helper video format functions
+ */
+static uint8_t rgb_to_y(int r, int g, int b)
+{
+    int y = ((9798 * r + 19235 * g + 3736 * b) >> 15);
+    return y > 255 ? 255 : y < 0 ? 0 : y;
+}
+
+static uint8_t rgb_to_u(int r, int g, int b)
+{
+    int u = ((-5538 * r + -10846 * g + 16351 * b) >> 15) + 128;
+    return u > 255 ? 255 : u < 0 ? 0 : u;
+}
+
+static uint8_t rgb_to_v(int r, int g, int b)
+{
+    int v = ((16351 * r + -13697 * g + -2664 * b) >> 15) + 128;
+    return v > 255 ? 255 : v < 0 ? 0 : v;
+}
+
+void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t *rgb, uint16_t width, uint16_t height)
+{
+    uint16_t x, y;
+    uint8_t *p;
+    uint8_t r, g, b;
+
+    for (y = 0; y != height; y += 2) {
+        p = rgb;
+
+        for (x = 0; x != width; x++) {
+            b = *rgb++;
+            g = *rgb++;
+            r = *rgb++;
+            rgb++;
+
+            *plane_y++ = rgb_to_y(r, g, b);
+        }
+
+        for (x = 0; x != width / 2; x++) {
+            b = *rgb++;
+            g = *rgb++;
+            r = *rgb++;
+            rgb++;
+
+            *plane_y++ = rgb_to_y(r, g, b);
+
+            b = *rgb++;
+            g = *rgb++;
+            r = *rgb++;
+            rgb++;
+
+            *plane_y++ = rgb_to_y(r, g, b);
+
+            b = ((int)b + (int) * (rgb - 8) + (int) * p + (int) * (p + 4) + 2) / 4;
+            p++;
+            g = ((int)g + (int) * (rgb - 7) + (int) * p + (int) * (p + 4) + 2) / 4;
+            p++;
+            r = ((int)r + (int) * (rgb - 6) + (int) * p + (int) * (p + 4) + 2) / 4;
+            p++;
+            p++;
+
+            *plane_u++ = rgb_to_u(r, g, b);
+            *plane_v++ = rgb_to_v(r, g, b);
+
+            p += 4;
+        }
+    }
+}
+/*
+ * End of helper video format functions
+ */
+
+
+
+/*
+ * Implementation for OSXVideo
+ */
+@implementation OSXVideo {
+    dispatch_queue_t _processingQueue;
+    AVCaptureSession *_session;
+    AVCaptureVideoDataOutput *_linkerVideo;
+
+    CVImageBufferRef _currentFrame;
+    pthread_mutex_t _frameLock;
+    BOOL _shouldMangleDimensions;
+}
+
+- (instancetype)initWithDeviceNames:
+    (char **)device_names AmtDevices:
+    (int *)size
+{
+    _session = [[AVCaptureSession alloc] init];
+
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType: AVMediaTypeVideo];
+    int i;
+
+    for (i = 0; i < [devices count]; ++i) {
+        AVCaptureDevice *device = [devices objectAtIndex: i];
+        char *video_input_name;
+        NSString *localizedName = [device localizedName];
+        video_input_name = (char *)malloc(strlen([localizedName cStringUsingEncoding: NSUTF8StringEncoding]) + 1);
+        strcpy(video_input_name, (char *)[localizedName cStringUsingEncoding: NSUTF8StringEncoding]);
+        device_names[i] = video_input_name;
+    }
+
+    if ( i <= 0 )
+        return nil;
+
+    *size = i;
+
+    return self;
+}
+
+- (void)dealloc
+{
+    pthread_mutex_destroy(&_frameLock);
+    [_session release];
+    [_linkerVideo release];
+    dispatch_release(_processingQueue);
+    [super dealloc];
+}
+
+- (int)openVideoDeviceIndex:
+    (uint32_t)device_idx Width:
+    (uint16_t *)width Height:
+    (uint16_t *)height
+{
+    pthread_mutex_init(&_frameLock, NULL);
+    pthread_mutex_lock(&_frameLock);
+    _processingQueue = dispatch_queue_create("Toxic processing queue", DISPATCH_QUEUE_SERIAL);
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType: AVMediaTypeVideo];
+    AVCaptureDevice *device = [devices objectAtIndex: device_idx];
+    NSError *error = NULL;
+    AVCaptureInput *input = [[AVCaptureDeviceInput alloc] initWithDevice: device error: &error];
+
+    if ( error != NULL ) {
+        [input release];
+        return -1;
+    }
+
+    [_session beginConfiguration];
+    [_session addInput: input];
+    //_session.sessionPreset = AVCaptureSessionPreset640x480;
+    //*width = 640;
+    //*height = 480;
+    _shouldMangleDimensions = YES;
+    [_session commitConfiguration];
+    [input release];
+    [device release];
+
+    /* Obtain device resolution */
+    AVCaptureInputPort *port = [input.ports objectAtIndex: 0];
+    CMFormatDescriptionRef format_description = port.formatDescription;
+
+    if ( format_description ) {
+        CMVideoDimensions dimensions = CMVideoFormatDescriptionGetDimensions(format_description);
+        *width = dimensions.width;
+        *height = dimensions.height;
+    } else {
+        *width = 0;
+        *height = 0;
+    }
+
+    _linkerVideo = [[AVCaptureVideoDataOutput alloc] init];
+    [_linkerVideo setSampleBufferDelegate: self queue: _processingQueue];
+
+    // TODO possibly get a better pixel format
+    if (_shouldMangleDimensions) {
+        [_linkerVideo setVideoSettings: @ {
+             (id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA),
+             (id)kCVPixelBufferWidthKey: @640,
+             (id)kCVPixelBufferHeightKey: @480
+                     }];
+    } else {
+        [_linkerVideo setVideoSettings: @ {(id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)}];
+    }
+
+    [_session addOutput: _linkerVideo];
+    [_session startRunning];
+
+    pthread_mutex_unlock(&_frameLock);
+    return 0;
+}
+
+- (void)closeVideoDeviceIndex:
+    (uint32_t)device_idx
+{
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType: AVMediaTypeVideo];
+    AVCaptureDevice *device = [devices objectAtIndex: device_idx];
+    NSError *error = NULL;
+    AVCaptureInput *input = [[AVCaptureDeviceInput alloc] initWithDevice: device error: &error];
+    [_session stopRunning];
+    [_session removeOutput: _linkerVideo];
+    [_session removeInput: input];
+    [_linkerVideo release];
+}
+
+- (void)captureOutput:
+    (AVCaptureOutput *)captureOutput didOutputSampleBuffer:
+    (CMSampleBufferRef)sampleBuffer fromConnection:
+    (AVCaptureConnection *)connection
+{
+    pthread_mutex_lock(&_frameLock);
+    CVImageBufferRef img = CMSampleBufferGetImageBuffer(sampleBuffer);
+
+    if (!img) {
+        NSLog(@"Toxic WARNING: Bad sampleBuffer from AVfoundation!");
+    } else {
+        CVPixelBufferUnlockBaseAddress(_currentFrame, kCVPixelBufferLock_ReadOnly);
+        RELEASE_CHK(CFRelease, _currentFrame);
+
+        _currentFrame = (CVImageBufferRef)CFRetain(img);
+        // we're not going to do anything to it, so it's safe to lock it always
+        CVPixelBufferLockBaseAddress(_currentFrame, kCVPixelBufferLock_ReadOnly);
+    }
+
+    pthread_mutex_unlock(&_frameLock);
+}
+
+- (int)getVideoFrameY:
+    (uint8_t *)y U:
+    (uint8_t *)u V:
+    (uint8_t *)v Width:
+    (uint16_t *)width Height:
+    (uint16_t *)height
+{
+    if (!_currentFrame) {
+        return -1;
+    }
+
+    pthread_mutex_lock(&_frameLock);
+    CFRetain(_currentFrame);
+
+    CFTypeID imageType = CFGetTypeID(_currentFrame);
+
+    if (imageType == CVPixelBufferGetTypeID()) {
+        // TODO maybe handle other formats
+        bgrxtoyuv420(y, u, v, CVPixelBufferGetBaseAddress(_currentFrame), *width, *height);
+    } else if (imageType == CVOpenGLBufferGetTypeID()) {
+        // OpenGL pbuffer
+    } else if (imageType == CVOpenGLTextureGetTypeID()) {
+        // OpenGL Texture (Do we need to handle these?)
+    }
+
+    CVPixelBufferRelease(_currentFrame);
+    pthread_mutex_unlock(&_frameLock);
+    return 0;
+}
+
+@end
+/*
+ * End of implementation for OSXVideo
+ */
+
+
+/*
+ * C-interface for OSXVideo
+ */
+static OSXVideo *_OSXVideo = nil;
+
+int osx_video_init(char **device_names, int *size)
+{
+    _OSXVideo = [[OSXVideo alloc] initWithDeviceNames: device_names AmtDevices: size];
+
+    if ( _OSXVideo == nil )
+        return -1;
+
+    return 0;
+}
+
+void osx_video_release()
+{
+    [_OSXVideo release];
+    _OSXVideo = nil;
+}
+
+int osx_video_open_device(uint32_t selection, uint16_t *width, uint16_t *height)
+{
+    if ( _OSXVideo == nil )
+        return -1;
+
+    return [_OSXVideo openVideoDeviceIndex: selection Width: width Height: height];
+}
+
+void osx_video_close_device(uint32_t device_idx)
+{
+    [_OSXVideo closeVideoDeviceIndex: device_idx];
+}
+
+int osx_video_read_device(uint8_t *y, uint8_t *u, uint8_t *v, uint16_t *width, uint16_t *height)
+{
+    if ( _OSXVideo == nil )
+        return -1;
+
+    return [_OSXVideo getVideoFrameY: y U: u V: v Width: width Height: height];
+}
+/*
+ * End of C-interface for OSXVideo
+ */
+
+#endif /* __OBJC__ */

src/prompt.c

@@ -31,6 +31,7 @@
 #include "toxic.h"
 #include "windows.h"
 #include "prompt.h"
+#include "friendlist.h"
 #include "execute.h"
 #include "misc_tools.h"
 #include "toxic_strings.h"
@@ -46,13 +47,21 @@ extern ToxWindow *prompt;
 extern struct user_settings *user_settings;
 extern struct Winthread Winthread;
 
+extern FriendsList Friends;
 FriendRequests FrndRequests;
-
-#ifdef AUDIO
-#define AC_NUM_GLOB_COMMANDS 18
+#if defined(PYTHON) && defined(VIDEO)
+#define AC_NUM_GLOB_COMMANDS 23
+#elif defined(PYTHON) && defined(AUDIO)
+#define AC_NUM_GLOB_COMMANDS 21
+#elif VIDEO
+#define AC_NUM_GLOB_COMMANDS 22
+#elif AUDIO
+#define AC_NUM_GLOB_COMMANDS 20
+#elif PYTHON
+#define AC_NUM_GLOB_COMMANDS 19
 #else
-#define AC_NUM_GLOB_COMMANDS 16
-#endif /* AUDIO */
+#define AC_NUM_GLOB_COMMANDS 18
+#endif
 
 /* Array of global command names used for tab completion. */
 static const char glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE] = {
@@ -67,8 +76,10 @@ static const char glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE] = {
     { "/help"       },
     { "/log"        },
     { "/myid"       },
+    { "/myqr"       },
     { "/nick"       },
     { "/note"       },
+    { "/nospam"     },
     { "/quit"       },
     { "/requests"   },
     { "/status"     },
@@ -79,6 +90,20 @@ static const char glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE] = {
     { "/sdev"        },
 
 #endif /* AUDIO */
+
+#ifdef VIDEO
+
+    { "/lsvdev"      },
+    { "/svdev"       },
+
+#endif /* VIDEO */
+
+#ifdef PYTHON
+
+    { "/run"         },
+
+#endif /* PYTHON */
+
 };
 
 void kill_prompt_window(ToxWindow *self)
@@ -173,16 +198,19 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
     getyx(self->window, y, x);
     getmaxyx(self->window, y2, x2);
 
-    if (x2 <= 0)
+    if (x2 <= 0 || y2 <= 0)
         return;
 
+    if (ctx->pastemode && key == '\r')
+        key = '\n';
+
     /* ignore non-menu related input if active */
     if (self->help->active) {
         help_onKey(self, key);
         return;
     }
 
-    if (ltr) {    /* char is printable */
+    if (ltr || key == '\n') {    /* char is printable */
         input_new_char(self, key, x, y, x2, y2);
         return;
     }
@@ -198,11 +226,18 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 
             if (wcsncmp(ctx->line, L"/avatar \"", wcslen(L"/avatar \"")) == 0)
                 diff = dir_match(self, m, ctx->line, L"/avatar");
-            else if (wcsncmp(ctx->line, L"/status ", wcslen(L"/status ")) == 0){
+
+#ifdef PYTHON
+            else if (wcsncmp(ctx->line, L"/run \"", wcslen(L"/run \"")) == 0)
+                diff = dir_match(self, m, ctx->line, L"/run");
+
+#endif
+
+            else if (wcsncmp(ctx->line, L"/status ", wcslen(L"/status ")) == 0) {
                 const char status_cmd_list[3][8] = {
-                  {"online"},
-                  {"away"},
-                  {"busy"},
+                    {"online"},
+                    {"away"},
+                    {"busy"},
                 };
                 diff = complete_line(self, status_cmd_list, 3, 8);
             } else
@@ -210,7 +245,7 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
 
             if (diff != -1) {
                 if (x + diff > x2 - 1) {
-                    int wlen = wcswidth(ctx->line, sizeof(ctx->line));
+                    int wlen = MAX(0, wcswidth(ctx->line, sizeof(ctx->line) / sizeof(wchar_t)));
                     ctx->start = wlen < x2 ? 0 : wlen - x2 + 1;
                 }
             } else {
@@ -219,19 +254,21 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
         } else {
             sound_notify(self, notif_error, 0, NULL);
         }
-    } else if (key == '\n') {
+    } else if (key == '\r') {
         rm_trailing_spaces_buf(ctx);
 
-        char 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))
+        if (!wstring_is_empty(ctx->line)) {
             add_line_to_hist(ctx);
+            wstrsubst(ctx->line, L'¶', L'\n');
 
-        line_info_add(self, NULL, NULL, NULL, PROMPT, 0, 0, "%s", line);
-        execute(ctx->history, self, m, line, GLOBAL_COMMAND_MODE);
+            char line[MAX_STR_SIZE] = {0};
+
+            if (wcs_to_mbs_buf(line, ctx->line, MAX_STR_SIZE) == -1)
+                memset(&line, 0, sizeof(line));
+
+            line_info_add(self, NULL, NULL, NULL, PROMPT, 0, 0, "%s", line);
+            execute(ctx->history, self, m, line, GLOBAL_COMMAND_MODE);
+        }
 
         wclear(ctx->linewin);
         wmove(self->window, y2 - CURS_Y_OFFSET, 0);
@@ -244,9 +281,15 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
     int x2, y2;
     getmaxyx(self->window, y2, x2);
 
+    if (y2 <= 0 || x2 <= 0)
+        return;
+
     ChatContext *ctx = self->chatwin;
 
+    pthread_mutex_lock(&Winthread.lock);
     line_info_print(self);
+    pthread_mutex_unlock(&Winthread.lock);
+
     wclear(ctx->linewin);
 
     curs_set(1);
@@ -255,22 +298,33 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
         mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
 
     StatusBar *statusbar = self->stb;
+
     mvwhline(statusbar->topline, 1, 0, ACS_HLINE, x2);
     wmove(statusbar->topline, 0, 0);
 
-    if (statusbar->connection != TOX_CONNECTION_NONE) {
+    pthread_mutex_lock(&Winthread.lock);
+    TOX_CONNECTION connection = statusbar->connection;
+    pthread_mutex_unlock(&Winthread.lock);
+
+    if (connection != TOX_CONNECTION_NONE) {
         int colour = MAGENTA;
         const char *status_text = "ERROR";
 
-        switch (statusbar->status) {
+        pthread_mutex_lock(&Winthread.lock);
+        TOX_USER_STATUS status = statusbar->status;
+        pthread_mutex_unlock(&Winthread.lock);
+
+        switch (status) {
             case TOX_USER_STATUS_NONE:
                 status_text = "Online";
                 colour = GREEN;
                 break;
+
             case TOX_USER_STATUS_AWAY:
                 status_text = "Away";
                 colour = YELLOW;
                 break;
+
             case TOX_USER_STATUS_BUSY:
                 status_text = "Busy";
                 colour = RED;
@@ -282,12 +336,16 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
         wattroff(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
 
         wattron(statusbar->topline, A_BOLD);
+        pthread_mutex_lock(&Winthread.lock);
         wprintw(statusbar->topline, " %s", statusbar->nick);
+        pthread_mutex_unlock(&Winthread.lock);
         wattroff(statusbar->topline, A_BOLD);
     } else {
         wprintw(statusbar->topline, " [Offline]");
         wattron(statusbar->topline, A_BOLD);
+        pthread_mutex_lock(&Winthread.lock);
         wprintw(statusbar->topline, " %s", statusbar->nick);
+        pthread_mutex_unlock(&Winthread.lock);
         wattroff(statusbar->topline, A_BOLD);
     }
 
@@ -296,11 +354,12 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
         char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH];
 
         pthread_mutex_lock(&Winthread.lock);
-        tox_self_get_status_message(m, (uint8_t *) statusmsg);
-        pthread_mutex_unlock(&Winthread.lock);
-
+        size_t slen = tox_self_get_status_message_size(m);
+        tox_self_get_status_message (m, (uint8_t *) statusmsg);
+        statusmsg[slen] = '\0';
         snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
         statusbar->statusmsg_len = strlen(statusbar->statusmsg);
+        pthread_mutex_unlock(&Winthread.lock);
     }
 
     self->x = x2;
@@ -308,6 +367,8 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
     /* Truncate note if it doesn't fit in statusbar */
     uint16_t maxlen = x2 - getcurx(statusbar->topline) - 3;
 
+    pthread_mutex_lock(&Winthread.lock);
+
     if (statusbar->statusmsg_len > maxlen) {
         statusbar->statusmsg[maxlen - 3] = '\0';
         strcat(statusbar->statusmsg, "...");
@@ -317,26 +378,25 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
     if (statusbar->statusmsg[0])
         wprintw(statusbar->topline, " : %s", statusbar->statusmsg);
 
+    pthread_mutex_unlock(&Winthread.lock);
+
     mvwhline(self->window, y2 - CHATBOX_HEIGHT, 0, ACS_HLINE, x2);
 
     int y, x;
     getyx(self->window, y, x);
     (void) x;
 
-    int new_x = ctx->start ? x2 - 1 : wcswidth(ctx->line, ctx->pos);
+    int new_x = ctx->start ? x2 - 1 : MAX(0, wcswidth(ctx->line, ctx->pos));
     wmove(self->window, y + 1, new_x);
 
-    wrefresh(self->window);
+    wnoutrefresh(self->window);
 
     if (self->help->active)
         help_onDraw(self);
 }
 
-static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnum , TOX_CONNECTION connection_status)
+static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnum, TOX_CONNECTION connection_status)
 {
-    if (friendnum < 0)
-        return;
-
     ChatContext *ctx = self->chatwin;
 
     char nick[TOX_MAX_NAME_LENGTH] = {0};    /* stop removing this initiation */
@@ -349,7 +409,11 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
     get_time_str(timefrmt, sizeof(timefrmt));
     const char *msg;
 
-    if (connection_status != TOX_CONNECTION_NONE) {
+    if (user_settings->show_connection_msg == SHOW_WELCOME_MSG_OFF) {
+        return;
+    }
+
+    if (connection_status != TOX_CONNECTION_NONE && Friends.list[friendnum].connection_status == TOX_CONNECTION_NONE) {
         msg = "has come online";
         line_info_add(self, timefrmt, nick, NULL, CONNECTION, 0, GREEN, msg);
         write_to_log(msg, nick, ctx->log, true);
@@ -360,7 +424,7 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
         else
             box_notify(self, user_log_in, NT_WNDALERT_2 | NT_NOTIFWND | NT_RESTOL, &self->active_box,
                        "Toxic", "%s has come online", nick );
-    } else {
+    } else if (connection_status == TOX_CONNECTION_NONE) {
         msg = "has gone offline";
         line_info_add(self, timefrmt, nick, NULL, DISCONNECTION, 0, RED, msg);
         write_to_log(msg, nick, ctx->log, true);
@@ -400,6 +464,10 @@ void prompt_init_statusbar(ToxWindow *self, Tox *m)
 {
     int x2, y2;
     getmaxyx(self->window, y2, x2);
+
+    if (y2 <= 0 || x2 <= 0)
+        exit_toxic_err("failed in prompt_init_statusbar", FATALERR_CURSES);
+
     (void) y2;
 
     /* Init statusbar info */
@@ -457,6 +525,9 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
     int y2, x2;
     getmaxyx(self->window, y2, x2);
 
+    if (y2 <= 0 || x2 <= 0)
+        exit_toxic_err("failed in prompt_onInit", FATALERR_CURSES);
+
     ChatContext *ctx = self->chatwin;
     ctx->history = subwin(self->window, y2 - CHATBOX_HEIGHT + 1, x2, 0, 0);
     ctx->linewin = subwin(self->window, CHATBOX_HEIGHT, x2, y2 - CHATBOX_HEIGHT, 0);
@@ -472,7 +543,9 @@ static void prompt_onInit(ToxWindow *self, Tox *m)
     if (user_settings->autolog == AUTOLOG_ON) {
         char myid[TOX_ADDRESS_SIZE];
         tox_self_get_address(m, (uint8_t *) myid);
-        log_enable(self->name, myid, NULL, ctx->log, LOG_PROMPT);
+
+        if (log_enable(self->name, myid, NULL, ctx->log, LOG_PROMPT) == -1)
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Warning: Log failed to initialize.");
     }
 
     scrollok(ctx->history, 0);
@@ -487,6 +560,7 @@ ToxWindow new_prompt(void)
     ToxWindow ret;
     memset(&ret, 0, sizeof(ret));
 
+    ret.num = -1;
     ret.active = true;
     ret.is_prompt = true;
 

src/prompt.h

@@ -41,6 +41,7 @@ typedef struct {
 } FriendRequests;
 
 ToxWindow new_prompt(void);
+
 void prep_prompt_win(void);
 void prompt_init_statusbar(ToxWindow *self, Tox *m);
 void prompt_update_nick(ToxWindow *prompt, const char *nick);

src/python_api.c

@@ -0,0 +1,347 @@
+/*  python_api.c
+ *
+ *
+ *  Copyright (C) 2017 Jakob Kreuze <jakob@memeware.net>
+ *
+ *  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 PYTHON
+#include <Python.h>
+#include "api.h"
+#endif /* PYTHON */
+
+#include "execute.h"
+
+extern Tox       *user_tox;
+
+static struct python_registered_func {
+    char     *name;
+    char     *help;
+    PyObject *callback;
+    struct python_registered_func *next;
+} python_commands = {0};
+
+static PyObject *python_api_display(PyObject *self, PyObject *args)
+{
+    const char *msg;
+
+    if (!PyArg_ParseTuple(args, "s", &msg))
+        return NULL;
+
+    api_display(msg);
+    return Py_None;
+}
+
+static PyObject *python_api_get_nick(PyObject *self, PyObject *args)
+{
+    char     *name;
+    PyObject *ret;
+
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+
+    name = api_get_nick();
+
+    if (name == NULL)
+        return NULL;
+
+    ret  = Py_BuildValue("s", name);
+    free(name);
+    return ret;
+}
+
+static PyObject *python_api_get_status(PyObject *self, PyObject *args)
+{
+    PyObject        *ret;
+
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+
+    switch (api_get_status()) {
+        case TOX_USER_STATUS_NONE:
+            ret = Py_BuildValue("s", "online");
+            break;
+
+        case TOX_USER_STATUS_AWAY:
+            ret = Py_BuildValue("s", "away");
+            break;
+
+        case TOX_USER_STATUS_BUSY:
+            ret = Py_BuildValue("s", "busy");
+            break;
+    }
+
+    return ret;
+}
+
+static PyObject *python_api_get_status_message(PyObject *self, PyObject *args)
+{
+    char     *status;
+    PyObject *ret;
+
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+
+    status = api_get_status_message();
+
+    if (status == NULL)
+        return NULL;
+
+    ret    = Py_BuildValue("s", status);
+    free(status);
+    return ret;
+}
+
+static PyObject *python_api_get_all_friends(PyObject *self, PyObject *args)
+{
+    size_t       i, ii;
+    FriendsList  friends;
+    PyObject    *cur, *ret;
+    char         pubkey_buf[TOX_PUBLIC_KEY_SIZE * 2 + 1];
+
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+
+    friends = api_get_friendslist();
+    ret     = PyList_New(0);
+
+    for (i = 0; i < friends.num_friends; i++) {
+        for (ii = 0; ii < TOX_PUBLIC_KEY_SIZE; ii++)
+            snprintf(pubkey_buf + ii * 2, 3, "%02X", friends.list[i].pub_key[ii] & 0xff);
+
+        pubkey_buf[TOX_PUBLIC_KEY_SIZE * 2] = '\0';
+        cur = Py_BuildValue("(s,s)", friends.list[i].name, pubkey_buf);
+        PyList_Append(ret, cur);
+    }
+
+    return ret;
+}
+
+static PyObject *python_api_send(PyObject *self, PyObject *args)
+{
+    const char *msg;
+
+    if (!PyArg_ParseTuple(args, "s", &msg))
+        return NULL;
+
+    api_send(msg);
+    return Py_None;
+}
+
+static PyObject *python_api_execute(PyObject *self, PyObject *args)
+{
+    int         mode;
+    const char *command;
+
+    if (!PyArg_ParseTuple(args, "si", &command, &mode))
+        return NULL;
+
+    api_execute(command, mode);
+    return Py_None;
+}
+
+static PyObject *python_api_register(PyObject *self, PyObject *args)
+{
+    struct python_registered_func *cur;
+    size_t      command_len, help_len;
+    const char *command, *help;
+    PyObject   *callback;
+
+    if (!PyArg_ParseTuple(args, "ssO:register_command", &command, &help, &callback))
+        return NULL;
+
+    if (!PyCallable_Check(callback)) {
+        PyErr_SetString(PyExc_TypeError, "Calback parameter must be callable");
+        return NULL;
+    }
+
+    if (command[0] != '/') {
+        PyErr_SetString(PyExc_TypeError, "Command must be prefixed with a '/'");
+        return NULL;
+    }
+
+    for (cur = &python_commands; ; cur = cur->next) {
+        if (cur->name != NULL && !strcmp(command, cur->name)) {
+            Py_XDECREF(cur->callback);
+            Py_XINCREF(callback);
+            cur->callback = callback;
+            break;
+        }
+
+        if (cur->next == NULL) {
+            Py_XINCREF(callback);
+            cur->next = malloc(sizeof(struct python_registered_func));
+
+            if (cur->next == NULL)
+                return PyErr_NoMemory();
+
+            command_len     = strlen(command);
+            cur->next->name = malloc(command_len + 1);
+
+            if (cur->next->name == NULL)
+                return PyErr_NoMemory();
+
+            strncpy(cur->next->name, command, command_len + 1);
+            help_len        = strlen(help);
+            cur->next->help = malloc(help_len + 1);
+
+            if (cur->next->help == NULL)
+                return PyErr_NoMemory();
+
+            strncpy(cur->next->help, help, help_len + 1);
+            cur->next->callback = callback;
+            cur->next->next     = NULL;
+            break;
+        }
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef ToxicApiMethods[] = {
+    {"display",            python_api_display,            METH_VARARGS, "Display a message to the current prompt"},
+    {"get_nick",           python_api_get_nick,           METH_VARARGS, "Return the user's current nickname"},
+    {"get_status",         python_api_get_status,         METH_VARARGS, "Returns the user's current status"},
+    {"get_status_message", python_api_get_status_message, METH_VARARGS, "Return the user's current status message"},
+    {"get_all_friends",    python_api_get_all_friends,    METH_VARARGS, "Return all of the user's friends"},
+    {"send",               python_api_send,               METH_VARARGS, "Send the message to the current user"},
+    {"execute",            python_api_execute,            METH_VARARGS, "Execute a command like `/nick`"},
+    {"register",           python_api_register,           METH_VARARGS, "Register a command like `/nick` to a Python function"},
+    {NULL,                 NULL,                          0,            NULL},
+};
+
+static struct PyModuleDef toxic_api_module = {
+    PyModuleDef_HEAD_INIT,
+    "toxic_api",
+    NULL,
+    -1,
+    ToxicApiMethods
+};
+
+PyMODINIT_FUNC PyInit_toxic_api(void)
+{
+    PyObject *m = PyModule_Create(&toxic_api_module);
+    PyObject *global_command_const    = Py_BuildValue("i", GLOBAL_COMMAND_MODE);
+    PyObject *chat_command_const      = Py_BuildValue("i", CHAT_COMMAND_MODE);
+    PyObject *groupchat_command_const = Py_BuildValue("i", GROUPCHAT_COMMAND_MODE);
+    PyObject_SetAttrString(m, "GLOBAL_COMMAND",    global_command_const);
+    PyObject_SetAttrString(m, "CHAT_COMMAND",      chat_command_const);
+    PyObject_SetAttrString(m, "GROUPCHAT_COMMAND", groupchat_command_const);
+    Py_DECREF(global_command_const);
+    Py_DECREF(chat_command_const);
+    Py_DECREF(groupchat_command_const);
+    return m;
+}
+
+void terminate_python(void)
+{
+    struct python_registered_func *cur, *old;
+
+    if (python_commands.name != NULL)
+        free(python_commands.name);
+
+    for (cur = python_commands.next; cur != NULL;) {
+        old = cur;
+        cur = cur->next;
+        free(old->name);
+        free(old);
+    }
+
+    Py_Finalize();
+}
+
+void init_python(Tox *m)
+{
+    user_tox = m;
+    PyImport_AppendInittab("toxic_api", PyInit_toxic_api);
+    Py_Initialize();
+}
+
+void run_python(FILE *fp, char *path)
+{
+    PyRun_SimpleFile(fp, path);
+}
+
+int do_python_command(int num_args, char (*args)[MAX_STR_SIZE])
+{
+    int i;
+    PyObject *callback_args, *args_strings;
+    struct python_registered_func *cur;
+
+    for (cur = &python_commands; cur != NULL; cur = cur->next) {
+        if (cur->name == NULL)
+            continue;
+
+        if (!strcmp(args[0], cur->name)) {
+            args_strings = PyList_New(0);
+
+            for (i = 1; i < num_args; i++)
+                PyList_Append(args_strings, Py_BuildValue("s", args[i]));
+
+            callback_args = PyTuple_Pack(1, args_strings);
+
+            if (PyObject_CallObject(cur->callback, callback_args) == NULL)
+                api_display("Exception raised in callback function");
+
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+int python_num_registered_handlers(void)
+{
+    int n = 0;
+    struct python_registered_func *cur;
+
+    for (cur = &python_commands; cur != NULL; cur = cur->next) {
+        if (cur->name != NULL)
+            n++;
+    }
+
+    return n;
+}
+
+int python_help_max_width(void)
+{
+    size_t tmp;
+    int    max = 0;
+    struct python_registered_func *cur;
+
+    for (cur = &python_commands; cur != NULL; cur = cur->next) {
+        if (cur->name != NULL) {
+            tmp = strlen(cur->help);
+            max = tmp > max ? tmp : max;
+        }
+    }
+
+    max = max > 50 ? 50 : max;
+    return 37 + max;
+}
+
+void python_draw_handler_help(WINDOW *win)
+{
+    struct python_registered_func *cur;
+
+    for (cur = &python_commands; cur != NULL; cur = cur->next) {
+        if (cur->name != NULL)
+            wprintw(win, "  %-29s: %.50s\n", cur->name, cur->help);
+    }
+}

src/python_api.h

@@ -0,0 +1,39 @@
+/*  python_api.h
+ *
+ *
+ *  Copyright (C) 2017 Jakob Kreuze <jakob@memeware.net>
+ *
+ *  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 PYTHON_API_H
+#define PYTHON_API_H
+
+#ifdef PYTHON
+#include <Python.h>
+#endif /* PYTHON */
+
+PyMODINIT_FUNC PyInit_toxic_api(void);
+void terminate_python(void);
+void init_python(Tox *m);
+void run_python(FILE *fp, char *path);
+int do_python_command(int num_args, char (*args)[MAX_STR_SIZE]);
+int python_num_registered_handlers(void);
+int python_help_max_width(void);
+void python_draw_handler_help(WINDOW *win);
+
+#endif /* #define PYTHON_API_H */

src/qr_code.c

@@ -0,0 +1,210 @@
+/*  qr_obj_code.c
+ *
+ *
+ *  Copyright (C) 2015 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/>.
+ *
+ */
+
+#include <stdlib.h>
+#include <qrencode.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "toxic.h"
+#include "windows.h"
+#include "qr_code.h"
+
+#ifdef QRPNG
+#include <png.h>
+#define INCHES_PER_METER (100.0/2.54)
+#define DPI 72
+#define SQUARE_SIZE 5
+#endif /* QRPNG */
+
+#define BORDER_LEN 1
+#define CHAR_1 "\342\226\210"
+#define CHAR_2 "\342\226\204"
+#define CHAR_3 "\342\226\200"
+
+/* Converts a tox ID string into a QRcode and prints it into the given filename.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int ID_to_QRcode_txt(const char *tox_id, const char *outfile)
+{
+    FILE *fp = fopen(outfile, "wb");
+
+    if (fp == NULL)
+        return -1;
+
+    QRcode *qr_obj = QRcode_encodeString(tox_id, 0, QR_ECLEVEL_L, QR_MODE_8, 0);
+
+    if (qr_obj == NULL) {
+        fclose(fp);
+        return -1;
+    }
+
+    size_t width = qr_obj->width;
+    size_t i, j;
+
+    for (i = 0; i < width + BORDER_LEN * 2; ++i)
+        fprintf(fp, "%s", CHAR_1);
+
+    fprintf(fp, "\n");
+
+    for (i = 0; i < width; i += 2) {
+        for (j = 0; j < BORDER_LEN; ++j)
+            fprintf(fp, "%s", CHAR_1);
+
+        const unsigned char *row_1 = qr_obj->data + width * i;
+        const unsigned char *row_2 = row_1 + width;
+
+        for (j = 0; j < width; ++j) {
+            bool x = row_1[j] & 1;
+            bool y = (i + 1) < width ? (row_2[j] & 1) : false;
+
+            if (x && y)
+                fprintf(fp, " ");
+            else if (x)
+                fprintf(fp, "%s", CHAR_2);
+            else if (y)
+                fprintf(fp, "%s", CHAR_3);
+            else
+                fprintf(fp, "%s", CHAR_1);
+        }
+
+        for (j = 0; j < BORDER_LEN; ++j)
+            fprintf(fp, "%s", CHAR_1);
+
+        fprintf(fp, "\n");
+    }
+
+    fclose(fp);
+    QRcode_free(qr_obj);
+
+    return 0;
+}
+
+#ifdef QRPNG
+/* Converts a tox ID string into a QRcode and prints it into the given filename as png.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int ID_to_QRcode_png(const char *tox_id, const char *outfile)
+{
+    static FILE *fp;
+    unsigned char *p;
+    unsigned char black[4] = {0, 0, 0, 255};
+    size_t x, y, xx, yy, real_width;
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    fp = fopen(outfile, "wb");
+
+    if (fp == NULL) {
+        return -1;
+    }
+
+    QRcode *qr_obj = QRcode_encodeString(tox_id, 0, QR_ECLEVEL_L, QR_MODE_8, 0);
+
+    if (qr_obj == NULL) {
+        fclose(fp);
+        return -1;
+    }
+
+    real_width = (qr_obj->width + BORDER_LEN * 2) * SQUARE_SIZE;
+    size_t row_size = real_width * 4;
+    unsigned char row[row_size];
+
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+
+    if (png_ptr == NULL) {
+        fclose(fp);
+        QRcode_free(qr_obj);
+        return -1;
+    }
+
+    info_ptr = png_create_info_struct(png_ptr);
+
+    if (info_ptr == NULL) {
+        fclose(fp);
+        QRcode_free(qr_obj);
+        return -1;
+    }
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        fclose(fp);
+        QRcode_free(qr_obj);
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        return -1;
+    }
+
+    png_init_io(png_ptr, fp);
+    png_set_IHDR(png_ptr, info_ptr, real_width, real_width, 8,
+                 PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
+                 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+    png_set_pHYs(png_ptr, info_ptr, DPI * INCHES_PER_METER,
+                 DPI * INCHES_PER_METER, PNG_RESOLUTION_METER);
+    png_write_info(png_ptr, info_ptr);
+
+    /* top margin */
+    memset(row, 0xff, row_size);
+
+    for (y = 0; y < BORDER_LEN * SQUARE_SIZE; y++) {
+        png_write_row(png_ptr, row);
+    }
+
+    /* data */
+    p = qr_obj->data;
+
+    for (y = 0; y < qr_obj->width; y++) {
+        memset(row, 0xff, row_size);
+
+        for (x = 0; x < qr_obj->width; x++) {
+            for (xx = 0; xx < SQUARE_SIZE; xx++) {
+                if (*p & 1) {
+                    memcpy(&row[((BORDER_LEN + x) * SQUARE_SIZE + xx) * 4], black, 4);
+                }
+            }
+
+            p++;
+        }
+
+        for (yy = 0; yy < SQUARE_SIZE; yy++) {
+            png_write_row(png_ptr, row);
+        }
+    }
+
+    /* bottom margin */
+    memset(row, 0xff, row_size);
+
+    for (y = 0; y < BORDER_LEN * SQUARE_SIZE; y++) {
+        png_write_row(png_ptr, row);
+    }
+
+    png_write_end(png_ptr, info_ptr);
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+
+    fclose(fp);
+    QRcode_free(qr_obj);
+
+    return 0;
+}
+#endif /* QRPNG */

src/qr_code.h

@@ -0,0 +1,45 @@
+/*  qr_code.h
+ *
+ *
+ *  Copyright (C) 2015 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 QR_CODE
+#define QR_CODE
+
+#define QRCODE_FILENAME_EXT ".QRcode"
+
+/* Converts a tox ID string into a QRcode and prints it into the given filename.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int ID_to_QRcode_txt(const char *tox_id, const char *outfile);
+
+#ifdef QRPNG
+#define QRCODE_FILENAME_EXT_PNG ".QRcode.png"
+/* Converts a tox ID string into a QRcode and prints it into the given filename as png.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int ID_to_QRcode_png(const char *tox_id, const char *outfile);
+#endif /* QRPNG */
+
+#endif /* QR_CODE */

src/settings.c

@@ -32,39 +32,45 @@
 #include "misc_tools.h"
 
 #ifdef AUDIO
-    #include "device.h"
+#include "audio_device.h"
 #endif /* AUDIO */
 
 #include "settings.h"
 #include "line_info.h"
 
 #ifndef PACKAGE_DATADIR
-    #define PACKAGE_DATADIR "."
+#define PACKAGE_DATADIR "."
 #endif
 
 #define NO_SOUND "silent"
 
 static struct ui_strings {
-    const char* self;
-    const char* timestamps;
-    const char* time_format;
-    const char* timestamp_format;
-    const char* log_timestamp_format;
-    const char* alerts;
-    const char* native_colors;
-    const char* autolog;
-    const char* history_size;
-    const char* show_typing_self;
-    const char* show_typing_other;
-    const char* show_welcome_msg;
+    const char *self;
+    const char *timestamps;
+    const char *time_format;
+    const char *timestamp_format;
+    const char *log_timestamp_format;
+    const char *alerts;
+    const char *bell_on_message;
+    const char *bell_on_filetrans;
+    const char *bell_on_filetrans_accept;
+    const char *bell_on_invite;
+    const char *native_colors;
+    const char *autolog;
+    const char *history_size;
+    const char *show_typing_self;
+    const char *show_typing_other;
+    const char *show_welcome_msg;
+    const char *show_connection_msg;
+    const char *nodeslist_update_freq;
 
-    const char* line_join;
-    const char* line_quit;
-    const char* line_alert;
-    const char* line_normal;
+    const char *line_join;
+    const char *line_quit;
+    const char *line_alert;
+    const char *line_normal;
 
-    const char* mplex_away;
-    const char* mplex_away_note;
+    const char *mplex_away;
+    const char *mplex_away_note;
 } ui_strings = {
     "ui",
     "timestamps",
@@ -72,12 +78,18 @@ static struct ui_strings {
     "timestamp_format",
     "log_timestamp_format",
     "alerts",
+    "bell_on_message",
+    "bell_on_filetrans",
+    "bell_on_filetrans_accept",
+    "bell_on_invite",
     "native_colors",
     "autolog",
     "history_size",
     "show_typing_self",
     "show_typing_other",
     "show_welcome_msg",
+    "show_connection_msg",
+    "nodeslist_update_freq",
     "line_join",
     "line_quit",
     "line_alert",
@@ -86,7 +98,7 @@ static struct ui_strings {
     "mplex_away_note",
 };
 
-static void ui_defaults(struct user_settings* settings)
+static void ui_defaults(struct user_settings *settings)
 {
     settings->timestamps = TIMESTAMPS_ON;
     snprintf(settings->timestamp_format, sizeof(settings->timestamp_format), "%s", TIMESTAMP_DEFAULT);
@@ -94,11 +106,17 @@ static void ui_defaults(struct user_settings* settings)
 
     settings->autolog = AUTOLOG_OFF;
     settings->alerts = ALERTS_ENABLED;
+    settings->bell_on_message = 0;
+    settings->bell_on_filetrans = 0;
+    settings->bell_on_filetrans_accept = 0;
+    settings->bell_on_invite = 0;
     settings->colour_theme = DFLT_COLS;
     settings->history_size = 700;
     settings->show_typing_self = SHOW_TYPING_ON;
     settings->show_typing_other = SHOW_TYPING_ON;
     settings->show_welcome_msg = SHOW_WELCOME_MSG_ON;
+    settings->show_connection_msg = SHOW_CONNECTION_MSG_ON;
+    settings->nodeslist_update_freq = 7;
 
     snprintf(settings->line_join, LINE_HINT_MAX + 1, "%s", LINE_JOIN);
     snprintf(settings->line_quit, LINE_HINT_MAX + 1, "%s", LINE_QUIT);
@@ -113,17 +131,18 @@ static void ui_defaults(struct user_settings* settings)
 }
 
 static const struct keys_strings {
-    const char* self;
-    const char* next_tab;
-    const char* prev_tab;
-    const char* scroll_line_up;
-    const char* scroll_line_down;
-    const char* half_page_up;
-    const char* half_page_down;
-    const char* page_bottom;
-    const char* peer_list_up;
-    const char* peer_list_down;
-    const char* toggle_peerlist;
+    const char *self;
+    const char *next_tab;
+    const char *prev_tab;
+    const char *scroll_line_up;
+    const char *scroll_line_down;
+    const char *half_page_up;
+    const char *half_page_down;
+    const char *page_bottom;
+    const char *peer_list_up;
+    const char *peer_list_down;
+    const char *toggle_peerlist;
+    const char *toggle_pastemode;
 } key_strings = {
     "keys",
     "next_tab",
@@ -136,10 +155,11 @@ static const struct keys_strings {
     "peer_list_up",
     "peer_list_down",
     "toggle_peerlist",
+    "toggle_paste_mode",
 };
 
 /* defines from toxic.h */
-static void key_defaults(struct user_settings* settings)
+static void key_defaults(struct user_settings *settings)
 {
     settings->key_next_tab = T_KEY_NEXT;
     settings->key_prev_tab = T_KEY_PREV;
@@ -151,33 +171,40 @@ static void key_defaults(struct user_settings* settings)
     settings->key_peer_list_up = T_KEY_C_LB;
     settings->key_peer_list_down = T_KEY_C_RB;
     settings->key_toggle_peerlist = T_KEY_C_B;
+    settings->key_toggle_pastemode = T_KEY_C_T;
 }
 
 static const struct tox_strings {
-    const char* self;
-    const char* download_path;
-    const char* chatlogs_path;
-    const char* avatar_path;
+    const char *self;
+    const char *download_path;
+    const char *chatlogs_path;
+    const char *avatar_path;
+    const char *autorun_path;
+    const char *password_eval;
 } tox_strings = {
     "tox",
     "download_path",
     "chatlogs_path",
     "avatar_path",
+    "autorun_path",
+    "password_eval",
 };
 
-static void tox_defaults(struct user_settings* settings)
+static void tox_defaults(struct user_settings *settings)
 {
     strcpy(settings->download_path, "");
     strcpy(settings->chatlogs_path, "");
     strcpy(settings->avatar_path, "");
+    strcpy(settings->autorun_path, "");
+    strcpy(settings->password_eval, "");
 }
 
 #ifdef AUDIO
 static const struct audio_strings {
-    const char* self;
-    const char* input_device;
-    const char* output_device;
-    const char* VAD_treshold;
+    const char *self;
+    const char *input_device;
+    const char *output_device;
+    const char *VAD_treshold;
 } audio_strings = {
     "audio",
     "input_device",
@@ -185,7 +212,7 @@ static const struct audio_strings {
     "VAD_treshold",
 };
 
-static void audio_defaults(struct user_settings* settings)
+static void audio_defaults(struct user_settings *settings)
 {
     settings->audio_in_dev = 0;
     settings->audio_out_dev = 0;
@@ -195,17 +222,17 @@ static void audio_defaults(struct user_settings* settings)
 
 #ifdef SOUND_NOTIFY
 static const struct sound_strings {
-    const char* self;
-    const char* notif_error;
-    const char* self_log_in;
-    const char* self_log_out;
-    const char* user_log_in;
-    const char* user_log_out;
-    const char* call_incoming;
-    const char* call_outgoing;
-    const char* generic_message;
-    const char* transfer_pending;
-    const char* transfer_completed;
+    const char *self;
+    const char *notif_error;
+    const char *self_log_in;
+    const char *self_log_out;
+    const char *user_log_in;
+    const char *user_log_out;
+    const char *call_incoming;
+    const char *call_outgoing;
+    const char *generic_message;
+    const char *transfer_pending;
+    const char *transfer_completed;
 } sound_strings = {
     "sounds",
     "notif_error",
@@ -221,11 +248,12 @@ static const struct sound_strings {
 };
 #endif
 
-static int key_parse(const char** bind){
+static int key_parse(const char **bind)
+{
     int len = strlen(*bind);
 
     if (len > 5) {
-        if(strncasecmp(*bind, "ctrl+", 5) == 0)
+        if (strncasecmp(*bind, "ctrl+", 5) == 0 && toupper(bind[0][5]) != 'M')  /* ctrl+m cannot be used */
             return toupper(bind[0][5]) - 'A' + 1;
     }
 
@@ -238,6 +266,15 @@ static int key_parse(const char** bind){
     return -1;
 }
 
+static void set_key_binding(int *key, const char **bind)
+{
+    int code = key_parse(bind);
+
+    if (code != -1) {
+        *key = code;
+    }
+}
+
 int settings_load(struct user_settings *s, const char *patharg)
 {
     config_t cfg[1];
@@ -286,6 +323,7 @@ int settings_load(struct user_settings *s, const char *patharg)
         config_setting_lookup_bool(setting, ui_strings.timestamps, &s->timestamps);
 
         int time = 24;
+
         if ( config_setting_lookup_int(setting, ui_strings.time_format, &time) ) {
             if (time == 12) {
                 snprintf(s->timestamp_format, sizeof(s->timestamp_format), "%s", "%I:%M:%S %p");
@@ -302,22 +340,45 @@ int settings_load(struct user_settings *s, const char *patharg)
         }
 
         config_setting_lookup_bool(setting, ui_strings.alerts, &s->alerts);
+
+        if (config_setting_lookup_bool(setting, ui_strings.bell_on_message, &s->bell_on_message)) {
+            s->bell_on_message = s->bell_on_message ? NT_BEEP : 0;
+        }
+
+        if (config_setting_lookup_bool(setting, ui_strings.bell_on_filetrans, &s->bell_on_filetrans)) {
+            s->bell_on_filetrans = s->bell_on_filetrans ? NT_BEEP : 0;
+        }
+
+        if (config_setting_lookup_bool(setting, ui_strings.bell_on_filetrans_accept, &s->bell_on_filetrans_accept)) {
+            s->bell_on_filetrans_accept = s->bell_on_filetrans_accept ? NT_BEEP : 0;
+        }
+
+        if (config_setting_lookup_bool(setting, ui_strings.bell_on_invite, &s->bell_on_invite)) {
+            s->bell_on_invite = s->bell_on_invite ? NT_BEEP : 0;
+        }
+
         config_setting_lookup_bool(setting, ui_strings.autolog, &s->autolog);
         config_setting_lookup_bool(setting, ui_strings.native_colors, &s->colour_theme);
-        config_setting_lookup_int(setting, ui_strings.history_size, &s->history_size);
         config_setting_lookup_bool(setting, ui_strings.show_typing_self, &s->show_typing_self);
         config_setting_lookup_bool(setting, ui_strings.show_typing_other, &s->show_typing_other);
         config_setting_lookup_bool(setting, ui_strings.show_welcome_msg, &s->show_welcome_msg);
+        config_setting_lookup_bool(setting, ui_strings.show_connection_msg, &s->show_connection_msg);
+
+        config_setting_lookup_int(setting, ui_strings.history_size, &s->history_size);
+        config_setting_lookup_int(setting, ui_strings.nodeslist_update_freq, &s->nodeslist_update_freq);
 
         if ( config_setting_lookup_string(setting, ui_strings.line_join, &str) ) {
             snprintf(s->line_join, sizeof(s->line_join), "%s", str);
         }
+
         if ( config_setting_lookup_string(setting, ui_strings.line_quit, &str) ) {
             snprintf(s->line_quit, sizeof(s->line_quit), "%s", str);
         }
+
         if ( config_setting_lookup_string(setting, ui_strings.line_alert, &str) ) {
             snprintf(s->line_alert, sizeof(s->line_alert), "%s", str);
         }
+
         if ( config_setting_lookup_string(setting, ui_strings.line_normal, &str) ) {
             snprintf(s->line_normal, sizeof(s->line_normal), "%s", str);
         }
@@ -359,34 +420,70 @@ int settings_load(struct user_settings *s, const char *patharg)
             if (len >= sizeof(s->avatar_path))
                 s->avatar_path[0] = '\0';
         }
+
+#ifdef PYTHON
+
+        if ( config_setting_lookup_string(setting, tox_strings.autorun_path, &str) ) {
+            snprintf(s->autorun_path, sizeof(s->autorun_path), "%s", str);
+            int len = strlen(str);
+
+            if (len >= sizeof(s->autorun_path) - 2)
+                s->autorun_path[0] = '\0';
+            else if (s->autorun_path[len - 1] != '/')
+                strcat(&s->autorun_path[len - 1], "/");
+        }
+
+#endif
+
+        if ( config_setting_lookup_string(setting, tox_strings.password_eval, &str) ) {
+            snprintf(s->password_eval, sizeof(s->password_eval), "%s", str);
+            int len = strlen(str);
+
+            if (len >= sizeof(s->password_eval))
+                s->password_eval[0] = '\0';
+        }
     }
 
     /* keys */
     if ((setting = config_lookup(cfg, key_strings.self)) != NULL) {
-        const char* tmp = NULL;
+        const char *tmp = NULL;
+
         if (config_setting_lookup_string(setting, key_strings.next_tab, &tmp))
-            s->key_next_tab = key_parse(&tmp);
+            set_key_binding(&s->key_next_tab, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.prev_tab, &tmp))
-            s->key_prev_tab = key_parse(&tmp);
+            set_key_binding(&s->key_prev_tab, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.scroll_line_up, &tmp))
-            s->key_scroll_line_up = key_parse(&tmp);
+            set_key_binding(&s->key_scroll_line_up, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.scroll_line_down, &tmp))
-            s->key_scroll_line_down= key_parse(&tmp);
+            set_key_binding(&s->key_scroll_line_down, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.half_page_up, &tmp))
-            s->key_half_page_up = key_parse(&tmp);
+            set_key_binding(&s->key_half_page_up, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.half_page_down, &tmp))
-            s->key_half_page_down = key_parse(&tmp);
+            set_key_binding(&s->key_half_page_down, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.page_bottom, &tmp))
-            s->key_page_bottom = key_parse(&tmp);
+            set_key_binding(&s->key_page_bottom, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.peer_list_up, &tmp))
-            s->key_peer_list_up = key_parse(&tmp);
+            set_key_binding(&s->key_peer_list_up, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.peer_list_down, &tmp))
-            s->key_peer_list_down = key_parse(&tmp);
+            set_key_binding(&s->key_peer_list_down, &tmp);
+
         if (config_setting_lookup_string(setting, key_strings.toggle_peerlist, &tmp))
-            s->key_toggle_peerlist = key_parse(&tmp);
+            set_key_binding(&s->key_toggle_peerlist, &tmp);
+
+        if (config_setting_lookup_string(setting, key_strings.toggle_pastemode, &tmp))
+            set_key_binding(&s->key_toggle_pastemode, &tmp);
     }
 
 #ifdef AUDIO
+
     if ((setting = config_lookup(cfg, audio_strings.self)) != NULL) {
         config_setting_lookup_int(setting, audio_strings.input_device, &s->audio_in_dev);
         s->audio_in_dev = s->audio_in_dev < 0 || s->audio_in_dev > MAX_DEVICES ? 0 : s->audio_in_dev;
@@ -396,9 +493,11 @@ int settings_load(struct user_settings *s, const char *patharg)
 
         config_setting_lookup_float(setting, audio_strings.VAD_treshold, &s->VAD_treshold);
     }
+
 #endif
 
 #ifdef SOUND_NOTIFY
+
     if ((setting = config_lookup(cfg, sound_strings.self)) != NULL) {
         if ( (config_setting_lookup_string(setting, sound_strings.notif_error, &str) != CONFIG_TRUE) ||
                 !set_sound(notif_error, str) ) {
@@ -447,8 +546,7 @@ int settings_load(struct user_settings *s, const char *patharg)
             if (str && strcasecmp(str, NO_SOUND) != 0)
                 set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/ToxicTransferComplete.wav");
         }
-    }
-    else {
+    } else {
         set_sound(notif_error, PACKAGE_DATADIR "/sounds/ToxicError.wav");
         set_sound(user_log_in, PACKAGE_DATADIR "/sounds/ToxicContactOnline.wav");
         set_sound(user_log_out, PACKAGE_DATADIR "/sounds/ToxicContactOffline.wav");
@@ -458,6 +556,7 @@ int settings_load(struct user_settings *s, const char *patharg)
         set_sound(transfer_pending, PACKAGE_DATADIR "/sounds/ToxicTransferStart.wav");
         set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/ToxicTransferComplete.wav");
     }
+
 #endif
 
     config_destroy(cfg);

src/settings.h

@@ -30,11 +30,19 @@
 /* Represents line_* hints max strlen */
 #define LINE_HINT_MAX 3
 
+#define PASSWORD_EVAL_MAX 512
+
 /* holds user setting values */
 struct user_settings {
     int autolog;           /* boolean */
     int alerts;            /* boolean */
 
+    /* boolean (is set to NT_BEEP or 0 after loading) */
+    int bell_on_message;
+    int bell_on_filetrans;
+    int bell_on_filetrans_accept;
+    int bell_on_invite;
+
     int timestamps;        /* boolean */
     char timestamp_format[TIME_STR_SIZE];
     char log_timestamp_format[TIME_STR_SIZE];
@@ -44,6 +52,8 @@ struct user_settings {
     int show_typing_self;  /* boolean */
     int show_typing_other; /* boolean */
     int show_welcome_msg;  /* boolean */
+    int show_connection_msg;  /* boolean */
+    int nodeslist_update_freq;  /* int (<= 0 to disable updates) */
 
     char line_join[LINE_HINT_MAX + 1];
     char line_quit[LINE_HINT_MAX + 1];
@@ -53,6 +63,8 @@ struct user_settings {
     char download_path[PATH_MAX];
     char chatlogs_path[PATH_MAX];
     char avatar_path[PATH_MAX];
+    char autorun_path[PATH_MAX];
+    char password_eval[PASSWORD_EVAL_MAX];
 
     int key_next_tab;
     int key_prev_tab;
@@ -64,6 +76,7 @@ struct user_settings {
     int key_peer_list_up;
     int key_peer_list_down;
     int key_toggle_peerlist;
+    int key_toggle_pastemode;
 
     int mplex_away; /* boolean (1 for reaction to terminal attach/detach) */
     char mplex_away_note [TOX_MAX_STATUS_MESSAGE_LENGTH];
@@ -94,6 +107,9 @@ enum {
     SHOW_WELCOME_MSG_OFF = 0,
     SHOW_WELCOME_MSG_ON = 1,
 
+    SHOW_CONNECTION_MSG_OFF = 0,
+    SHOW_CONNECTION_MSG_ON = 1,
+
     DFLT_HST_SIZE = 700,
 
     MPLEX_OFF = 0,

src/term_mplex.c

@@ -52,8 +52,7 @@ extern struct Winthread Winthread;
 #define PATH_SEP_S "/"
 #define PATH_SEP_C '/'
 
-typedef enum
-{
+typedef enum {
     MPLEX_NONE,
     MPLEX_SCREEN,
     MPLEX_TMUX,
@@ -97,13 +96,14 @@ static char *read_into_dyn_buffer (FILE *stream)
     char *dyn_buffer = NULL;
     int dyn_buffer_size = 1; /* account for the \0 */
 
-    while ((input_ptr = fgets (buffer, BUFFER_SIZE, stream)) != NULL)
-    {
+    while ((input_ptr = fgets (buffer, BUFFER_SIZE, stream)) != NULL) {
         int length = dyn_buffer_size + strlen (input_ptr);
+
         if (dyn_buffer)
-            dyn_buffer = (char*) realloc (dyn_buffer, length);
+            dyn_buffer = (char *) realloc (dyn_buffer, length);
         else
-            dyn_buffer = (char*) malloc (length);
+            dyn_buffer = (char *) malloc (length);
+
         strcpy (dyn_buffer + dyn_buffer_size - 1, input_ptr);
         dyn_buffer_size = length;
     }
@@ -116,26 +116,29 @@ static char *extract_socket_path (const char *info)
     const char *search_str = " Socket";
     const char *pos = strstr (info, search_str);
     char *end = NULL;
-    char* path = NULL;
+    char *path = NULL;
 
     if (!pos)
         return NULL;
 
     pos += strlen (search_str);
     pos = strchr (pos, PATH_SEP_C);
+
     if (!pos)
         return NULL;
 
     end = strchr (pos, '\n');
+
     if (!end)
         return NULL;
 
     *end = '\0';
     end = strrchr (pos, '.');
+
     if (!end)
         return NULL;
 
-    path = (char*) malloc (end - pos + 1);
+    path = (char *) malloc (end - pos + 1);
     *end = '\0';
     return strcpy (path, pos);
 }
@@ -147,14 +150,17 @@ static int detect_gnu_screen ()
     char *dyn_buffer = NULL;
 
     socket_name = getenv ("STY");
+
     if (!socket_name)
         goto nomplex;
 
     session_info_stream = popen ("env LC_ALL=C screen -ls", "r");
+
     if (!session_info_stream)
         goto nomplex;
 
     dyn_buffer = read_into_dyn_buffer (session_info_stream);
+
     if (!dyn_buffer)
         goto nomplex;
 
@@ -162,11 +168,16 @@ static int detect_gnu_screen ()
     session_info_stream = NULL;
 
     socket_path = extract_socket_path (dyn_buffer);
+
     if (!socket_path)
         goto nomplex;
 
     free (dyn_buffer);
     dyn_buffer = NULL;
+
+    if (strlen(socket_path) + strlen(PATH_SEP_S) + strlen(socket_name) >= sizeof(mplex_data))
+        goto nomplex;
+
     strcpy (mplex_data, socket_path);
     strcat (mplex_data, PATH_SEP_S);
     strcat (mplex_data, socket_name);
@@ -177,26 +188,34 @@ static int detect_gnu_screen ()
     return 1;
 
 nomplex:
+
     if (session_info_stream)
         pclose (session_info_stream);
+
     if (dyn_buffer)
         free (dyn_buffer);
+
+    if (socket_path)
+        free(socket_path);
+
     return 0;
 }
 
 static int detect_tmux ()
 {
     char *tmux_env = getenv ("TMUX"), *pos;
+
     if (!tmux_env)
         return 0;
 
     /* find second separator */
     pos = strrchr (tmux_env, ',');
+
     if (!pos)
         return 0;
 
-    /* store the session number string for later use */
-    strcpy (mplex_data, pos + 1);
+    /* store the session id for later use */
+    snprintf (mplex_data, sizeof(mplex_data), "$%s", pos + 1);
     mplex = MPLEX_TMUX;
     return 1;
 }
@@ -224,6 +243,7 @@ static int gnu_screen_is_detached ()
         return 0;
 
     struct stat sb;
+
     if (stat (mplex_data, &sb) != 0)
         return 0;
 
@@ -232,14 +252,8 @@ static int gnu_screen_is_detached ()
 }
 
 /* Detects tmux attached/detached by getting session data and finding the
-   current session's entry. An attached entry ends with "(attached)". Example:
-
-    $ tmux list-sessions
-    0: 1 windows (created Mon Mar  2 21:48:29 2015) [80x23] (attached)
-    1: 2 windows (created Mon Mar  2 21:48:43 2015) [80x23]
-
-    In this example, session 0 is attached and session 1 is detached.
-*/
+   current session's entry.
+ */
 static int tmux_is_detached ()
 {
     if (mplex != MPLEX_TMUX)
@@ -247,14 +261,18 @@ static int tmux_is_detached ()
 
     FILE *session_info_stream = NULL;
     char *dyn_buffer = NULL, *search_str = NULL;
-    char *entry_pos, *nl_pos, *attached_pos;
+    char *entry_pos;
+    int detached;
     const int numstr_len = strlen (mplex_data);
 
-    session_info_stream = popen ("env LC_ALL=C tmux list-sessions", "r");
+    /* get the number of attached clients for each session */
+    session_info_stream = popen ("tmux list-sessions -F \"#{session_id} #{session_attached}\"", "r");
+
     if (!session_info_stream)
         goto fail;
 
     dyn_buffer = read_into_dyn_buffer (session_info_stream);
+
     if (!dyn_buffer)
         goto fail;
 
@@ -262,13 +280,12 @@ static int tmux_is_detached ()
     session_info_stream = NULL;
 
     /* prepare search string, for finding the current session's entry */
-    search_str = (char*) malloc (numstr_len + 4);
+    search_str = (char *) malloc (numstr_len + 2);
     search_str[0] = '\n';
     strcpy (search_str + 1, mplex_data);
-    strcat (search_str, ": ");
 
     /* do the search */
-    if (strncmp (dyn_buffer, search_str + 1, numstr_len + 2) == 0)
+    if (strncmp (dyn_buffer, search_str + 1, numstr_len) == 0)
         entry_pos = dyn_buffer;
     else
         entry_pos = strstr (dyn_buffer, search_str);
@@ -276,9 +293,8 @@ static int tmux_is_detached ()
     if (! entry_pos)
         goto fail;
 
-    /* find the next \n and look for the "(attached)" before it */
-    nl_pos = strchr (entry_pos + 1, '\n');
-    attached_pos = strstr (entry_pos + 1, "(attached)\n");
+    entry_pos = strchr (entry_pos, ' ') + 1;
+    detached = strncmp (entry_pos, "0\n", 2) == 0;
 
     free (search_str);
     search_str = NULL;
@@ -286,15 +302,19 @@ static int tmux_is_detached ()
     free (dyn_buffer);
     dyn_buffer = NULL;
 
-    return attached_pos == NULL  ||  attached_pos > nl_pos;
+    return detached;
 
 fail:
+
     if (session_info_stream)
         pclose (session_info_stream);
+
     if (dyn_buffer)
         free (dyn_buffer);
+
     if (search_str)
         free (search_str);
+
     return 0;
 }
 
@@ -326,24 +346,21 @@ static void mplex_timer_handler (Tox *m)
     current_status = tox_self_get_status (m);
     pthread_mutex_unlock (&Winthread.lock);
 
-    if (auto_away_active && current_status == TOX_USER_STATUS_AWAY && !detached)
-    {
+    if (auto_away_active && current_status == TOX_USER_STATUS_AWAY && !detached) {
         auto_away_active = false;
         new_status = prev_status;
         new_note = prev_note;
-    }
-    else
-    if (current_status == TOX_USER_STATUS_NONE && detached)
-    {
+    } else if (current_status == TOX_USER_STATUS_NONE && detached) {
         auto_away_active = true;
         prev_status = current_status;
         new_status = TOX_USER_STATUS_AWAY;
         pthread_mutex_lock (&Winthread.lock);
-        tox_self_get_status_message (m, (uint8_t*) prev_note);
+        size_t slen = tox_self_get_status_message_size(m);
+        tox_self_get_status_message (m, (uint8_t *) prev_note);
+        prev_note[slen] = '\0';
         pthread_mutex_unlock (&Winthread.lock);
         new_note = user_settings->mplex_away_note;
-    }
-    else
+    } else
         return;
 
     char argv[3][MAX_STR_SIZE];

src/toxic.h

@@ -49,6 +49,10 @@
 #define KEY_IDENT_DIGITS 3    /* number of hex digits to display for the pub-key based identifier */
 #define TIME_STR_SIZE 32
 
+#ifndef MAX_PORT_RANGE
+#define MAX_PORT_RANGE 65535
+#endif
+
 /* ASCII key codes */
 #define T_KEY_ESC        0x1B     /* ESC key */
 #define T_KEY_KILL       0x0B     /* ctrl-k */
@@ -66,6 +70,7 @@
 #define T_KEY_C_L        0x0C     /* ctrl-l */
 #define T_KEY_C_W        0x17     /* ctrl-w */
 #define T_KEY_C_B        0x02     /* ctrl-b */
+#define T_KEY_C_T        0x14     /* ctrl-t */
 #define T_KEY_TAB        0x09     /* TAB key */
 
 #define ONLINE_CHAR "*"
@@ -83,7 +88,8 @@ typedef enum _FATAL_ERRS {
     FATALERR_WININIT = -9,          /* window init failed */
     FATALERR_PROXY = -10,           /* Tox network failed to init using a proxy */
     FATALERR_ENCRYPT = -11,         /* Data file encryption failure */
-    FATALERR_TOX_INIT = -12,      /* Tox instance failed to initialize */
+    FATALERR_TOX_INIT = -12,        /* Tox instance failed to initialize */
+    FATALERR_CURSES = -13,          /* Unrecoverable Ncurses error */
 } FATAL_ERRS;
 
 /* Fixes text color problem on some terminals.
@@ -101,18 +107,23 @@ int store_data(Tox *m, const char *path);
 /* callbacks */
 void on_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata);
 void on_connectionchange(Tox *m, uint32_t friendnumber, TOX_CONNECTION status, void *userdata);
-void on_message(Tox *m, uint32_t friendnumber, TOX_MESSAGE_TYPE type, const uint8_t *string, size_t length, void *userdata);
+void on_message(Tox *m, uint32_t friendnumber, TOX_MESSAGE_TYPE type, const uint8_t *string, size_t length,
+                void *userdata);
 void on_action(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata);
 void on_nickchange(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata);
 void on_statuschange(Tox *m, uint32_t friendnumber, TOX_USER_STATUS status, void *userdata);
 void on_statusmessagechange(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata);
 void on_friendadded(Tox *m, uint32_t friendnumber, bool sort);
-void on_groupmessage(Tox *m, int groupnumber, int peernumber, const uint8_t *message, uint16_t length, void *userdata);
-void on_groupaction(Tox *m, int groupnumber, int peernumber, const uint8_t *action, uint16_t length, void *userdata);
-void on_groupinvite(Tox *m, int32_t friendnumber, uint8_t type, const uint8_t *group_pub_key, uint16_t length, void *userdata);
-void on_group_namelistchange(Tox *m, int groupnumber, int peernumber, uint8_t change, void *userdata);
-void on_group_titlechange(Tox *m, int groupnumber, int peernumber, const uint8_t *title, uint8_t length, void *userdata);
-void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint64_t position, size_t length, void *userdata);
+void on_groupmessage(Tox *m, uint32_t groupnumber, uint32_t peernumber, TOX_MESSAGE_TYPE type,
+                     const uint8_t *message, size_t length, void *userdata);
+void on_groupinvite(Tox *m, uint32_t friendnumber, TOX_CONFERENCE_TYPE type, const uint8_t *group_pub_key,
+                    size_t length, void *userdata);
+void on_group_namelistchange(Tox *m, uint32_t groupnumber, uint32_t peernumber, TOX_CONFERENCE_STATE_CHANGE change,
+                             void *userdata);
+void on_group_titlechange(Tox *m, uint32_t groupnumber, uint32_t peernumber, const uint8_t *title, size_t length,
+                          void *userdata);
+void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint64_t position, size_t length,
+                           void *userdata);
 void on_file_recv_chunk(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data,
                         size_t length, void *userdata);
 void on_file_control (Tox *m, uint32_t friendnumber, uint32_t filenumber, TOX_FILE_CONTROL control, void *userdata);
@@ -121,9 +132,4 @@ void on_file_recv(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint32_t k
 void on_typing_change(Tox *m, uint32_t friendnumber, bool is_typing, void *userdata);
 void on_read_receipt(Tox *m, uint32_t friendnumber, uint32_t receipt, void *userdata);
 
-#ifdef AUDIO
-void write_device_callback_group(Tox *m, int groupnum, int peernum, const int16_t *pcm, unsigned int samples,
-                                 uint8_t channels, unsigned int sample_rate, void *arg);
-#endif  /* AUDIO */
-
 #endif  /* #define TOXIC_H */

src/toxic_strings.c

@@ -136,13 +136,13 @@ int del_word_buf(ChatContext *ctx)
     int i = ctx->pos, count = 0;
 
     /* traverse past empty space */
-    while (i > 0 && ctx->line[i-1] == L' ') {
+    while (i > 0 && ctx->line[i - 1] == L' ') {
         ++count;
         --i;
     }
 
     /* traverse past last entered word */
-    while (i > 0 && ctx->line[i-1] != L' ') {
+    while (i > 0 && ctx->line[i - 1] != L' ') {
         ++count;
         --i;
     }
@@ -166,19 +166,19 @@ void reset_buf(ChatContext *ctx)
     ctx->start = 0;
 }
 
-/* Removes trailing spaces from line. */
+/* Removes trailing spaces and newlines from line. */
 void rm_trailing_spaces_buf(ChatContext *ctx)
 {
     if (ctx->len <= 0)
         return;
 
-    if (ctx->line[ctx->len - 1] != ' ')
+    if (ctx->line[ctx->len - 1] != ' ' && ctx->line[ctx->len - 1] != L'¶')
         return;
 
     int i;
 
     for (i = ctx->len - 1; i >= 0; --i) {
-        if (ctx->line[i] != ' ')
+        if (ctx->line[i] != ' ' && ctx->line[i] != L'¶')
             break;
     }
 
@@ -242,3 +242,21 @@ void fetch_hist_item(ChatContext *ctx, int key_dir)
     ctx->pos = h_len;
     ctx->len = h_len;
 }
+
+void strsubst(char *str, char old, char new)
+{
+    int i;
+
+    for (i = 0; str[i] != '\0'; ++i)
+        if (str[i] == old)
+            str[i] = new;
+}
+
+void wstrsubst(wchar_t *str, wchar_t old, wchar_t new)
+{
+    int i;
+
+    for (i = 0; str[i] != L'\0'; ++i)
+        if (str[i] == old)
+            str[i] = new;
+}

src/toxic_strings.h

@@ -49,7 +49,7 @@ void reset_buf(ChatContext *ctx);
    Return 0 on success, -1 if yank buffer is empty or too long */
 int yank_buf(ChatContext *ctx);
 
-/* Deletes all characters from line starting at pos and going backwards 
+/* Deletes all characters from line starting at pos and going backwards
    until we find a space or run out of characters.
    Return 0 on success, -1 if no line or already at the beginning */
 int del_word_buf(ChatContext *ctx);
@@ -66,4 +66,8 @@ void add_line_to_hist(ChatContext *ctx);
    resets line if at end of history */
 void fetch_hist_item(ChatContext *ctx, int key_dir);
 
+/* Substitutes all occurrences of old with new. */
+void strsubst(char *str, char old, char new);
+void wstrsubst(wchar_t *str, wchar_t old, wchar_t new);
+
 #endif /* #define TOXIC_STRINGS_H */

src/video_call.c

@@ -0,0 +1,426 @@
+/*  video_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/>.
+ *
+ */
+
+#include "toxic.h"
+#include "windows.h"
+#include "video_call.h"
+#include "video_device.h"
+#include "chat_commands.h"
+#include "global_commands.h"
+#include "line_info.h"
+#include "notify.h"
+
+#include <stdbool.h>
+#include <curses.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#define default_video_bit_rate 5000
+
+void receive_video_frame_cb( ToxAV *av, uint32_t friend_number,
+                             uint16_t width, uint16_t height,
+                             uint8_t const *y, uint8_t const *u, uint8_t const *v,
+                             int32_t ystride, int32_t ustride, int32_t vstride,
+                             void *user_data );
+
+void video_bit_rate_status_cb( ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate,
+                               uint32_t video_bit_rate, void *user_data);
+
+static void print_err (ToxWindow *self, const char *error_str)
+{
+    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", error_str);
+}
+
+ToxAV *init_video(ToxWindow *self, Tox *tox)
+{
+    CallControl.video_errors = ve_None;
+
+    CallControl.video_enabled = true;
+    CallControl.video_bit_rate = 0;
+    CallControl.video_frame_duration = 10;
+
+    if ( !CallControl.av ) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video failed to init with ToxAV instance");
+
+        return NULL;
+    }
+
+    if ( init_video_devices(CallControl.av) == vde_InternalError ) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to init video devices");
+
+        return NULL;
+    }
+
+    toxav_callback_video_receive_frame(CallControl.av, receive_video_frame_cb, &CallControl);
+    toxav_callback_bit_rate_status(CallControl.av, video_bit_rate_status_cb, &CallControl);
+
+    return CallControl.av;
+}
+
+void terminate_video()
+{
+    int i;
+
+    for (i = 0; i < MAX_CALLS; ++i) {
+        Call *this_call = &CallControl.calls[i];
+
+        stop_video_transmission(this_call, i);
+
+        if ( this_call->vout_idx != -1 )
+            close_video_device(vdt_output, this_call->vout_idx);
+    }
+
+    terminate_video_devices();
+}
+
+void read_video_device_callback(int16_t width, int16_t height, const uint8_t *y, const uint8_t *u, const uint8_t *v,
+                                void *data)
+{
+    uint32_t friend_number = *((uint32_t *)data); /* TODO: Or pass an array of call_idx's */
+    Call *this_call = &CallControl.calls[friend_number];
+    TOXAV_ERR_SEND_FRAME error;
+
+    /* Drop frame if video sending is disabled */
+    if ( CallControl.video_bit_rate == 0 || this_call->vin_idx == -1 ) {
+        line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video frame dropped.");
+        return;
+    }
+
+    if ( toxav_video_send_frame(CallControl.av, friend_number, width, height, y, u, v, &error ) == false ) {
+        line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to send video frame");
+
+        if ( error == TOXAV_ERR_SEND_FRAME_NULL )
+            line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to capture video frame");
+        else if ( error == TOXAV_ERR_SEND_FRAME_INVALID )
+            line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare video frame");
+    }
+}
+
+void write_video_device_callback(uint32_t friend_number, uint16_t width, uint16_t height,
+                                 uint8_t const *y, uint8_t const *u, uint8_t const *v,
+                                 int32_t ystride, int32_t ustride, int32_t vstride,
+                                 void *user_data)
+{
+    write_video_out(width, height, y, u, v, ystride, ustride, vstride, user_data);
+}
+
+int start_video_transmission(ToxWindow *self, ToxAV *av, Call *call)
+{
+    if ( !self || !av) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare transmission");
+        return -1;
+    }
+
+    CallControl.video_bit_rate = default_video_bit_rate;
+
+    if ( toxav_bit_rate_set(CallControl.av, self->num, -1, CallControl.video_bit_rate, NULL) == false ) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set video bit rate");
+        return -1;
+    }
+
+    if ( open_primary_video_device(vdt_input, &call->vin_idx) != vde_None ) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open input video device!");
+        return -1;
+    }
+
+    if ( register_video_device_callback(self->num, call->vin_idx, read_video_device_callback, &self->num) != vde_None ) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to register input video handler!");
+        return -1;
+    }
+
+    return 0;
+}
+
+int stop_video_transmission(Call *call, int friend_number)
+{
+    CallControl.video_bit_rate = 0;
+    toxav_bit_rate_set(CallControl.av, friend_number, -1, CallControl.video_bit_rate, NULL);
+
+    if ( call->vin_idx != -1 ) {
+        close_video_device(vdt_input, call->vin_idx);
+        call->vin_idx = -1;
+    }
+
+    return 0;
+}
+/*
+ * End of transmission
+ */
+
+
+
+
+
+/*
+ * Callbacks
+ */
+void receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
+                            uint16_t width, uint16_t height,
+                            uint8_t const *y, uint8_t const *u, uint8_t const *v,
+                            int32_t ystride, int32_t ustride, int32_t vstride,
+                            void *user_data)
+{
+    write_video_device_callback(friend_number, width, height, y, u, v, ystride, ustride, vstride, user_data);
+}
+
+void video_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate,
+                              uint32_t video_bit_rate, void *user_data)
+{
+    CallControl.video_bit_rate = video_bit_rate;
+    toxav_bit_rate_set(CallControl.av, friend_number, -1, CallControl.video_bit_rate, NULL);
+}
+
+void callback_recv_video_starting(uint32_t friend_number)
+{
+    Call *this_call = &CallControl.calls[friend_number];
+
+    if ( this_call->vout_idx != -1 )
+        return;
+
+    open_primary_video_device(vdt_output, &this_call->vout_idx);
+}
+void callback_recv_video_end(uint32_t friend_number)
+{
+    Call *this_call = &CallControl.calls[friend_number];
+
+    close_video_device(vdt_output, this_call->vout_idx);
+    this_call->vout_idx = -1;
+}
+void callback_video_starting(uint32_t friend_number)
+{
+    ToxWindow *windows = CallControl.prompt;
+    Call *this_call = &CallControl.calls[friend_number];
+
+    TOXAV_ERR_CALL_CONTROL error = TOXAV_ERR_CALL_CONTROL_OK;
+    toxav_call_control(CallControl.av, friend_number, TOXAV_CALL_CONTROL_SHOW_VIDEO, &error);
+
+    if (error == TOXAV_ERR_CALL_CONTROL_OK) {
+        size_t i;
+
+        for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
+            if ( windows[i].is_call && windows[i].num == friend_number ) {
+                if ( 0 != start_video_transmission(&windows[i], CallControl.av, this_call) ) {
+                    line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
+                    return;
+                }
+
+                line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Video capture starting.");
+            }
+        }
+    }
+}
+void callback_video_end(uint32_t friend_number)
+{
+    stop_video_transmission(&CallControl.calls[friend_number], friend_number);
+}
+/*
+ * End of Callbacks
+ */
+
+
+
+/*
+ * Commands from chat_commands.h
+ */
+void cmd_video(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    const char *error_str;
+    Call *this_call = &CallControl.calls[self->num];
+
+    if ( argc != 0 ) {
+        error_str = "Unknown arguments.";
+        goto on_error;
+    }
+
+    if ( !CallControl.av ) {
+        error_str = "ToxAV not supported!";
+        goto on_error;
+    }
+
+    if ( !self->stb->connection ) {
+        error_str = "Friend is offline.";
+        goto on_error;
+    }
+
+    if ( !self->is_call ) {
+        error_str = "Not in call!";
+        goto on_error;
+    }
+
+    if ( this_call->vin_idx == -1 )
+        callback_video_starting(self->num);
+    else
+        callback_video_end(self->num);
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    const char *error_str;
+
+    if ( argc != 1 ) {
+        if ( argc < 1 ) error_str = "Type must be specified!";
+        else error_str = "Only one argument allowed!";
+
+        goto on_error;
+    }
+
+    VideoDeviceType type;
+
+    if ( strcasecmp(argv[1], "in") == 0 ) /* Input devices */
+        type = vdt_input;
+
+    else if ( strcasecmp(argv[1], "out") == 0 ) /* Output devices */
+        type = vdt_output;
+
+    else {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
+        return;
+    }
+
+    print_video_devices(self, type);
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+/* This changes primary video device only */
+void cmd_change_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    const char *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;
+    }
+
+    VideoDeviceType type;
+
+    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+        type = vdt_input;
+
+    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+        type = vdt_output;
+
+    else {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
+        return;
+    }
+
+
+    char *end;
+    long int selection = strtol(argv[2], &end, 10);
+
+    if ( *end ) {
+        error_str = "Invalid input";
+        goto on_error;
+    }
+
+    if ( set_primary_video_device(type, selection) == vde_InvalidSelection ) {
+        error_str = "Invalid selection!";
+        goto on_error;
+    }
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    const char *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;
+    }
+
+    VideoDeviceType type;
+
+    if ( strcmp(argv[1], "in") == 0 ) /* Input devices */
+        type = vdt_input;
+
+    else if ( strcmp(argv[1], "out") == 0 ) /* Output devices */
+        type = vdt_output;
+
+    else {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
+        return;
+    }
+
+
+    char *end;
+    long int selection = strtol(argv[2], &end, 10);
+
+    if ( *end ) {
+        error_str = "Invalid input";
+        goto on_error;
+    }
+
+    if ( video_selection_valid(type, selection) == vde_InvalidSelection ) {
+        error_str = "Invalid selection!";
+        goto on_error;
+    }
+
+    /* If call is active, change device */
+    if ( self->is_call ) {
+        Call *this_call = &CallControl.calls[self->num];
+
+        if ( this_call->ttas ) {
+
+            if ( type == vdt_output ) {
+            } else {
+                /* TODO: check for failure */
+                close_video_device(vdt_input, this_call->vin_idx);
+                open_video_device(vdt_input, selection, &this_call->vin_idx);
+                register_video_device_callback(self->num, this_call->vin_idx, read_video_device_callback, &self->num);
+            }
+        }
+    }
+
+    self->video_device_selection[type] = selection;
+
+    return;
+on_error:
+    print_err (self, error_str);
+}
+
+void stop_video_stream(ToxWindow *self)
+{
+    Call *this_call = &CallControl.calls[self->num];
+
+    if (this_call && this_call->vin_idx != -1)
+        stop_video_transmission(this_call, self->num);
+}

src/video_call.h

@@ -0,0 +1,44 @@
+/*  video_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 VIDEO_CALL_H
+#define VIDEO_CALL_H
+
+#include <tox/toxav.h>
+
+#include "audio_call.h"
+
+#include "video_device.h"
+
+/* You will have to pass pointer to first member of 'windows' declared in windows.c */
+ToxAV *init_video(ToxWindow *self, Tox *tox);
+void terminate_video();
+int start_video_transmission(ToxWindow *self, ToxAV *av, Call *call);
+int stop_video_transmission(Call *call, int friend_number);
+void stop_video_stream(ToxWindow *self);
+
+void callback_recv_video_starting(uint32_t friend_number);
+void callback_recv_video_end(uint32_t friend_number);
+void callback_video_starting(uint32_t friend_number);
+void callback_video_end(uint32_t friend_number);
+
+#endif /* VIDEO_CALL_H */