Bump to version 0.8.1

Merge branch 'f8l-pkgsrc'
Do not assume what is not Linux or a BSD descendant is OSX
2025-06-26 19:36:45 +02:00 · 2017-11-17 17:44:56 -05:00 · 2017-11-16 16:03:20 -05:00 · 2017-11-15 21:02:10 +01:00 · 2017-11-15 02:25:55 -05:00 · 2017-11-15 05:56:13 +02:00
90 changed files with 4598 additions and 1675 deletions
--- a/.gitignore
+++ b/.gitignore
@ -16,3 +16,4 @@ stamp-h1
 build/toxic
 build/*.o
 build/*.d
+apidoc/python/build
--- a/CHANGELOG.md
+++ b/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)*
--- a/INSTALL.md
+++ b/INSTALL.md
@ -1,57 +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*              |
+| [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/irungentoo/toxcore) | AUDIO                      | *None*              |
+| [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](#docs)

-<a name="deps_osx" />
+<sup>1</sup>: see [Documentation](#documentation)
+
 #### 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.

-<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)
@ -60,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")
-
--- a/11
+++ b/11
@ -11,10 +11,10 @@ CFLAGS += '-DPACKAGE_DATADIR="$(abspath $(DATADIR))"'
 CFLAGS += $(USER_CFLAGS)
 LDFLAGS = $(USER_LDFLAGS)

-OBJ = chat.o chat_commands.o configdir.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 avatars.o name_lookup.o qr_code.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)
@ -30,6 +30,9 @@ 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
--- a/README.md
+++ b/README.md
@ -3,7 +3,7 @@
       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/irungentoo/toxcore), and is now available as a standalone application.
+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)

--- a/apidoc/python/Makefile
+++ b/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)
--- a/apidoc/python/source/conf.py
+++ b/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'),
+]
+
+
+
--- a/apidoc/python/source/examples.rst
+++ b/apidoc/python/source/examples.rst
@ -0,0 +1,8 @@
+============
+API Examples
+============
+
+Fortune
+=======
+.. literalinclude:: fortune.py
+   :language: python
--- a/apidoc/python/source/fortune.py
+++ b/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)
--- a/apidoc/python/source/index.rst
+++ b/apidoc/python/source/index.rst
@ -0,0 +1,9 @@
+Toxic Scripting Interface Documentation
+=======================================
+
+.. toctree::
+   :maxdepth: 2
+
+   intro
+   reference
+   examples
--- a/apidoc/python/source/intro.rst
+++ b/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.
--- a/apidoc/python/source/reference.rst
+++ b/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
--- a/11
+++ b/11
@ -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
--- a/cfg/checks/audio.mk
+++ b/cfg/checks/audio.mk
@ -18,4 +18,4 @@ else ifneq ($(MAKECMDGOALS), clean)
    $(warning WARNING -- Toxic will be compiled without audio support)
    $(warning WARNING -- You need these libraries for audio support)
    $(warning WARNING -- $(MISSING_AUDIO_LIBS))
-endif
+endif
--- a/cfg/checks/check_features.mk
+++ b/cfg/checks/check_features.mk
@ -34,6 +34,18 @@ 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")
 ifneq ($(CHECK_LIBS), error)
--- a/cfg/checks/python.mk
+++ b/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
--- a/cfg/checks/qr_png.mk
+++ b/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
--- a/cfg/checks/video.mk
+++ b/cfg/checks/video.mk
@ -8,14 +8,14 @@ else
 endif

 # Check if we can build video support
-CHECK_VIDEO_LIBS = $(shell pkg-config --exists $(VIDEO_LIBS) || echo -n "error")
+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)
+    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
+endif
--- a/cfg/global_vars.mk
+++ b/cfg/global_vars.mk
@ -1,5 +1,5 @@
 # Version
-TOXIC_VERSION = 0.7.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 nameservers 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
--- a/cfg/targets/help.mk
+++ b/cfg/targets/help.mk
@ -14,6 +14,8 @@ help:
 	@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))\")"
--- a/cfg/targets/install.mk
+++ b/cfg/targets/install.mk
@ -35,7 +35,7 @@ install: $(BUILD_DIR)/toxic
 		mv temp_file $$file ;\
 		sed -e 's:__DATADIR__:'$(abspath $(DATADIR))':g' $$file > temp_file && \
 		mv temp_file $$file ;\
-		gzip -f -9 $$file ;\
+		gzip -f -n -9 $$file ;\
 	done

 .PHONY: install
--- a/doc/toxic.1
+++ b/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: 2015-07-08
+.\"      Date: 2016-09-20
 .\"    Manual: Toxic Manual
 .\"    Source: toxic __VERSION__
 .\"  Language: English
 .\"
-.TH "TOXIC" "1" "2015\-07\-08" "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
@ -122,12 +122,14 @@ Unencrypt a data file\&. A warning will appear if this option is used with a dat
 .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
@ -144,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>
@ -153,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
--- a/doc/toxic.1.asc
+++ b/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
@ -68,10 +67,11 @@ OPTIONS

 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)

@ -83,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
 -------
@ -97,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
--- a/doc/toxic.conf.5
+++ b/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-03-28
+.\" 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\-03\-28" "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"
--- a/doc/toxic.conf.5.asc
+++ b/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

--- a/misc/DHTnodes
+++ b/misc/DHTnodes
@ -1,17 +0,0 @@
-144.76.60.215 33445 04119E835DF3E78BACF0F84235B300546AF8B936F035185E2A8E9E0A67C8924F
-23.226.230.47 33445 A09162D68618E742FFBCA1C2C70385E6679604B2D80EA6E84AD0996A1AC8A074
-178.21.112.187 33445 4B2C19E924972CB9B57732FB172F8A8604DE13EEDA2A6234E348983344B23057
-195.154.119.113 33445 E398A69646B8CEACA9F0B84F553726C1C49270558C57DF5F3C368F05A7D71354
-192.210.149.121 33445 F404ABAA1C99A9D37D61AB54898F56793E1DEF8BD46B1038B9D822E8460FAB67
-46.38.239.179 33445 F5A1A38EFB6BD3C2C8AF8B10D85F0F89E931704D349F1D0720C3C4059AF2440A
-178.62.250.138 33445 788236D34978D1D5BD822F0A5BEBD2C53C64CC31CD3149350EE27D4D9A2F9B6B
-130.133.110.14 33445 461FA3776EF0FA655F1A05477DF1B3B614F7D6B124F7DB1DD4FE3C08B03B640F
-104.167.101.29 33445 5918AC3C06955962A75AD7DF4F80A5D7C34F7DB9E1498D2E0495DE35B3FE8A57
-205.185.116.116 33445 A179B09749AC826FF01F37A9613F6B57118AE014D4196A0E1105A98F93A54702
-198.98.51.198 33445 1D5A5F2F5D6233058BF0259B09622FB40B482E4FA0931EB8FD3AB8E7BF7DAF6F
-80.232.246.79 33445 A7A060D553B017D9D8F038E265C7AFB6C70BAAC55070197F9C007432D0038E0F
-108.61.165.198 33445 8E7D0B859922EF569298B4D261A8CCB5FEA14FB91ED412A7603A585A25698832
-212.71.252.109 33445 C4CEB8C7AC607C6B374E2E782B3C00EA3A63B80D4910B8649CCACDD19F260819
-194.249.212.109 33445 3CEE1F054081E7A011234883BC4FC39F661A55B73637A5AC293DDF1251D9432B
-185.25.116.107 33445 DA4E4ED4B697F2E9B000EEFE3A34B554ACD3F45F5C96EAEA2516DD7FF9AF7B43
-192.99.168.140 33445 6A4D0607A296838434A6A7DDF99F50EF9D60A2C510BBF31FE538A25CB6B4652F
--- a/misc/nameservers
+++ b/misc/nameservers
@ -1,2 +1 @@
 toxme.io 1A39E7A5D5FA9CF155C751570A32E625698A60A55F6D88028F949F66144F4F25
-
--- a/misc/toxic.conf.example
+++ b/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;
 };
@ -69,6 +87,9 @@ tox = {
  // 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";
 };
-
--- a/src/api.c
+++ b/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);
+}
--- a/src/api.h
+++ b/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 */
--- a/src/audio_call.c
+++ b/src/audio_call.c
@ -61,7 +61,7 @@ extern FriendsList Friends;

 #define frame_size (CallControl.audio_sample_rate * CallControl.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;
@ -75,17 +75,18 @@ static int set_call(Call* call, bool start)

        if ( pthread_mutex_init(&call->mutex, NULL) != 0 )
            return -1;
-    }
-    else {
+    } else {
        call->ttid = 0;
+
        if ( pthread_mutex_destroy(&call->mutex) != 0 )
-               return -1;
+            return -1;
    }

    return 0;
 }

-void call_cb                 ( ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data );
+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 );
@ -103,7 +104,8 @@ void callback_call_canceled ( uint32_t friend_number );
 void callback_call_rejected ( uint32_t friend_number );
 void callback_call_ended    ( uint32_t friend_number );

-void write_device_callback( uint32_t friend_number, const int16_t* PCM, uint16_t size );
+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)
 {
@ -120,9 +122,9 @@ ToxAV *init_audio(ToxWindow *self, Tox *tox)
    CallControl.av = toxav_new(tox, &error);

    CallControl.audio_enabled = true;
-    CallControl.audio_bit_rate = 48;
+    CallControl.audio_bit_rate = 64;
    CallControl.audio_sample_rate = 48000;
-    CallControl.audio_frame_duration = 10;
+    CallControl.audio_frame_duration = 20;
    CallControl.audio_channels = 1;

 #ifndef VIDEO
@ -157,6 +159,7 @@ ToxAV *init_audio(ToxWindow *self, Tox *tox)
 void terminate_audio()
 {
    int i;
+
    for (i = 0; i < MAX_CALLS; ++i)
        stop_transmission(&CallControl.calls[i], i);

@ -166,7 +169,7 @@ void terminate_audio()
    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)
 {
    TOXAV_ERR_SEND_FRAME error;
    uint32_t friend_number = *((uint32_t *)data); /* TODO: Or pass an array of call_idx's */
@ -174,16 +177,17 @@ void read_device_callback(const int16_t* captured, uint32_t size, void* data)
                           ((int64_t) CallControl.audio_frame_duration) / 1000;

    if ( sample_count <= 0 || toxav_audio_send_frame(CallControl.av, friend_number,
-                                                     captured, sample_count,
-                                                     CallControl.audio_channels,
-                                                     CallControl.audio_sample_rate, &error) == false )
-    {}
+            captured, sample_count,
+            CallControl.audio_channels,
+            CallControl.audio_sample_rate, &error) == false ) {
+    }
 }

-void write_device_callback(uint32_t friend_number, const int16_t* PCM, uint16_t size)
+void write_device_callback(uint32_t friend_number, const int16_t *PCM, uint16_t sample_count, uint8_t channels,
+                           uint32_t sample_rate)
 {
    if ( CallControl.calls[friend_number].ttas )
-        write_out(CallControl.calls[friend_number].out_idx, PCM, size, CallControl.audio_channels);
+        write_out(CallControl.calls[friend_number].out_idx, PCM, sample_count, channels, sample_rate);
 }

 int start_transmission(ToxWindow *self, Call *call)
@ -197,7 +201,7 @@ int start_transmission(ToxWindow *self, Call *call)
        return -1;

    DeviceError error = open_primary_device(input, &call->in_idx,
-            CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels);
+                                            CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels);

    if ( error != de_None ) {
        if ( error == de_FailedStart)
@ -208,12 +212,12 @@ int start_transmission(ToxWindow *self, Call *call)
    }

    if ( register_device_callback(self->num, call->in_idx,
-            read_device_callback, &self->num, true) != de_None)
+                                  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,
-            CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.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;
    }
@ -226,7 +230,7 @@ int stop_transmission(Call *call, uint32_t friend_number)
    if ( call->ttas ) {
        TOXAV_ERR_CALL_CONTROL error = TOXAV_ERR_CALL_CONTROL_OK;

-        if ( CallControl.call_state != TOXAV_FRIEND_CALL_STATE_FINISHED )
+        if ( CallControl.call_state > TOXAV_FRIEND_CALL_STATE_FINISHED )
            toxav_call_control(CallControl.av, friend_number, TOXAV_CALL_CONTROL_CANCEL, &error);

        if ( error == TOXAV_ERR_CALL_CONTROL_OK ) {
@ -284,7 +288,8 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
            callback_call_ended(friend_number);
            CallControl.pending_call = false;

-        break;
+            break;
+
        case ( TOXAV_FRIEND_CALL_STATE_FINISHED ):
            if ( CallControl.pending_call )
                callback_call_rejected(friend_number);
@ -302,7 +307,8 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
            CallControl.call_state = 0;
            CallControl.pending_call = false;

-        break;
+            break;
+
        default:
            if ( CallControl.pending_call ) {
                /* Start answered call */
@ -311,6 +317,7 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_

            } else {
 #ifdef VIDEO
+
                /* Handle receiving client video call states */
                if ( state & TOXAV_FRIEND_CALL_STATE_SENDING_V )
                    callback_recv_video_starting(friend_number);
@ -320,21 +327,22 @@ void callstate_cb(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_
 #endif /* VIDEO */
            }

-        break;
+            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)
+                            int16_t const *pcm, size_t sample_count,
+                            uint8_t channels, uint32_t sampling_rate, void *user_data)
 {
-    write_device_callback(friend_number, pcm, frame_size);
+    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)
@ -371,14 +379,16 @@ void callback_recv_ringing(uint32_t friend_number)
 }
 void callback_recv_starting(uint32_t friend_number)
 {
-    ToxWindow* windows = CallControl.prompt;
+    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!");
+                line_info_add(&windows[i], NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");

            return;
        }
@ -397,12 +407,14 @@ void callback_recv_ending(uint32_t friend_number)
 }
 void callback_call_started(uint32_t friend_number)
 {
-    ToxWindow* windows = CallControl.prompt;
+    ToxWindow *windows = CallControl.prompt;

    int i;
+
    for (i = 0; i < MAX_WINDOWS_NUM; ++i)
        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;
@ -477,6 +489,7 @@ void cmd_call(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
    }

    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";
@ -516,6 +529,7 @@ void cmd_answer(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
    }

    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!";
@ -570,8 +584,8 @@ void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
 {
    const char *error_str = NULL;

-    if ( !self->is_call ) {
-        error_str = "Not in a call.";
+    if ( !CallControl.av ) {
+        error_str = "Audio not supported!";
        goto on_error;
    }

@ -580,8 +594,8 @@ void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
        goto on_error;
    }

-    if ( !CallControl.av ) {
-        error_str = "Audio not supported!";
+    if ( !self->is_call && !CallControl.pending_call ) {
+        error_str = "Not in a call.";
        goto on_error;
    }

@ -589,18 +603,7 @@ void cmd_hangup(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[
    callback_video_end(self->num);
 #endif /* VIDEO */

-    if ( CallControl.pending_call ) {
-        /* Manually send a cancel call control because call hasn't started */
-        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;
-
+    stop_current_call(self);
    return;
 on_error:
    print_err (self, error_str);
@ -630,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;
@ -673,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;
    }

@ -717,13 +723,14 @@ 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->is_call ) {
-        Call* this_call = &CallControl.calls[self->num];
+        Call *this_call = &CallControl.calls[self->num];
+
        if ( this_call->ttas ) {


@ -731,15 +738,14 @@ void cmd_ccur_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
                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,
-                    CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.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, CallControl.audio_sample_rate,
-                    CallControl.audio_frame_duration, CallControl.audio_channels);
+                            CallControl.audio_frame_duration, CallControl.audio_channels);
                /* Set VAD as true for all; TODO: Make it more dynamic */
                register_device_callback(self->num, this_call->in_idx, read_device_callback, &self->num, true);
            }
@ -749,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);
 }

@ -780,9 +786,10 @@ void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA

    /* If call is active, use this_call values */
    if ( self->is_call ) {
-        Call* this_call = &CallControl.calls[self->num];
+        Call *this_call = &CallControl.calls[self->num];

        pthread_mutex_lock(&this_call->mutex);
+
        if ( type == input ) {
            device_mute(type, this_call->in_idx);
            self->chatwin->infobox.in_is_muted ^= 1;
@ -790,12 +797,13 @@ void cmd_mute(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
            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);
 }

@ -830,11 +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])
 {
-    Call *this_call = &CallControl.calls[self->num];
+    char *error_str;

-    if (this_call && self->is_call)
-        stop_transmission(this_call, self->num);
+    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;
 }
--- a/src/audio_device.c
+++ b/src/audio_device.c
@ -56,7 +56,7 @@ 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 */
+    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 */
@ -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 */
@ -90,43 +90,24 @@ pthread_mutex_t mutex;


 bool thread_running = true,
-      thread_paused = true;               /* Thread control */
+     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;

@ -152,12 +133,45 @@ DeviceError terminate_devices()
    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];
+    Device *device = running[type][device_idx];

    if (!device) {
        unlock;
@ -174,9 +188,10 @@ 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) {
        unlock;
@ -194,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);
 }
@ -210,7 +227,8 @@ 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;

@ -221,10 +239,13 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx
    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 ) {
@ -238,7 +259,7 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx
        }
    }

-    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;
@ -254,12 +275,12 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx
    if (type == input) {
        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 ) {
            free(device);
            running[type][*device_idx] = NULL;
@ -275,10 +296,10 @@ DeviceError open_device(DeviceType type, int32_t selection, uint32_t* device_idx
        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);
@ -306,7 +327,7 @@ 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) {
@ -317,32 +338,30 @@ DeviceError close_device(DeviceType type, uint32_t device_idx)
    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 friend_number, uint32_t device_idx, DataHandleCallback callback, void* data, bool enable_VAD)
+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;
@ -357,11 +376,12 @@ DeviceError register_device_callback( int32_t friend_number, uint32_t device_idx
    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;

@ -373,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 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.
@ -409,23 +429,27 @@ void* thread_poll (void* arg) // TODO: maybe use thread for every input source
    int32_t sample = 0;


-    while (true)
-    {
+    while (1) {
        lock;
+
        if (!thread_running) {
            unlock;
            break;
        }
+
+        bool paused = thread_paused;
        unlock;

-        if (thread_paused) usleep(10000); /* Wait for unpause. */
-        else
-        {
-            for (i = 0; i < size[input]; ++i)
-            {
+        /* 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);
@ -434,7 +458,8 @@ void* thread_poll (void* arg) // TODO: maybe use thread for every input source
                        unlock;
                        continue;
                    }
-                    Device* device = running[input][i];
+
+                    Device *device = running[input][i];

                    int16_t frame[16000];
                    alcCaptureSamples(device->dhndl, frame, f_size);
@ -446,8 +471,10 @@ void* thread_poll (void* arg) // TODO: maybe use thread for every input source

                    if ( device->cb ) device->cb(frame, f_size, device->cb_data);
                }
+
                unlock;
            }
+
            usleep(5000);
        }
    }
@ -455,12 +482,13 @@ void* thread_poll (void* arg) // TODO: maybe use thread for every input source
    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;
 }
@ -470,7 +498,7 @@ 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)
        return NULL;
--- a/src/audio_device.h
+++ b/src/audio_device.h
@ -22,7 +22,7 @@

 /*
 * 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.
 */

@ -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 friend_number, 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,16 +77,19 @@ 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);
--- a/src/autocomplete.c
+++ b/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,
@ -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];
@ -164,8 +170,11 @@ 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 = strlen(match);
+    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)
@ -187,8 +196,9 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
    char tmpend[MAX_STR_SIZE];
    snprintf(tmpend, sizeof(tmpend), "%s", &ubuf[ctx->pos]);

-    if (match_len + n_endchrs + strlen(tmpend) >= sizeof(ubuf))
+    if (match_len + n_endchrs + strlen(tmpend) >= sizeof(ubuf)) {
        return -1;
+    }

    strcpy(&ubuf[strt], match);
    strcpy(&ubuf[strt + match_len], endchrs);
@ -197,8 +207,9 @@ int complete_line(ToxWindow *self, const void *list, int n_items, int size)
    /* convert to widechar and copy back to original buf */
    wchar_t newbuf[MAX_STR_SIZE];

-    if (mbs_to_wcs_buf(newbuf, ubuf, sizeof(newbuf) / sizeof(wchar_t)) == -1)
+    if (mbs_to_wcs_buf(newbuf, ubuf, sizeof(newbuf) / sizeof(wchar_t)) == -1) {
        return -1;
+    }

    wcscpy(ctx->line, newbuf);

@ -276,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;
        }
--- a/src/avatars.c
+++ b/src/avatars.c
@ -55,6 +55,7 @@ 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;

@ -150,6 +151,7 @@ void on_avatar_file_control(Tox *m, struct FileTransfer *ft, TOX_FILE_CONTROL co
            } else if (ft->state == FILE_TRANSFER_PAUSED) {
                ft->state = FILE_TRANSFER_STARTED;
            }
+
            break;

        case TOX_FILE_CONTROL_PAUSE:
--- a/src/bootstrap.c
+++ b/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();
+    }
+}
--- a/src/bootstrap.h
+++ b/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 */
--- a/src/chat.c
+++ b/src/chat.c
@ -48,9 +48,9 @@
 #include "message_queue.h"

 #ifdef AUDIO
-    #include "audio_call.h"
+#include "audio_call.h"
 #ifdef VIDEO
-    #include "video_call.h"
+#include "video_call.h"
 #endif  /* VIDEO */
 #endif  /* AUDIO */

@ -65,8 +65,12 @@ static void init_infobox(ToxWindow *self);
 static void kill_infobox(ToxWindow *self);
 #endif  /* AUDIO */

-#ifdef AUDIO
-#define AC_NUM_CHAT_COMMANDS 30
+#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 22
 #endif /* AUDIO */
@ -106,8 +110,15 @@ static const char chat_cmd_list[AC_NUM_CHAT_COMMANDS][MAX_CMDNAME_SIZE] = {
    { "/mute"       },
    { "/sense"      },
    { "/video"      },
+    { "/bitrate"    },

 #endif /* AUDIO */
+
+#ifdef PYTHON
+
+    { "/run"        },
+
+#endif /* PYTHON */
 };

 static void set_self_typingstatus(ToxWindow *self, Tox *m, bool is_typing)
@ -126,11 +137,6 @@ void kill_chat_window(ToxWindow *self, Tox *m)
    ChatContext *ctx = self->chatwin;
    StatusBar *statusbar = self->stb;

-    kill_all_file_transfers_friend(m, self->num);
-    log_disable(ctx->log);
-    line_info_cleanup(ctx->hst);
-    cqueue_cleanup(ctx->cqueue);
-
 #ifdef AUDIO
 #ifdef VIDEO
    stop_video_stream(self);
@ -138,6 +144,11 @@ void kill_chat_window(ToxWindow *self, Tox *m)
    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);
+
    delwin(ctx->linewin);
    delwin(ctx->history);
    delwin(statusbar->topline);
@ -152,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;

@ -160,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,
@ -174,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)
@ -215,7 +230,14 @@ 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);

-    if (connection_status != TOX_CONNECTION_NONE && statusbar->connection == TOX_CONNECTION_NONE) {
+    TOX_CONNECTION prev_status = statusbar->connection;
+    statusbar->connection = connection_status;
+
+    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_senders(self, m, num);
@ -235,8 +257,6 @@ static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, TOX_C
        line_info_add(self, timefrmt, nick, NULL, DISCONNECTION, 0, RED, msg);
        write_to_log(msg, nick, ctx->log, true);
    }
-
-    statusbar->connection = connection_status;
 }

 static void chat_onTypingChange(ToxWindow *self, Tox *m, uint32_t num, bool is_typing)
@ -445,11 +465,11 @@ static void chat_onFileControl(ToxWindow *self, Tox *m, uint32_t friendnum, uint
            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.",
-                                                                      ft->index, ft->file_name);
+                              ft->index, ft->file_name);
                char progline[MAX_STR_SIZE];
                init_progress_bar(progline);
                line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "%s", progline);
-                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;
@ -457,10 +477,12 @@ static void chat_onFileControl(ToxWindow *self, Tox *m, uint32_t friendnum, uint

            break;
        }
+
        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.", ft->file_name);
            close_file_transfer(self, m, ft, -1, msg, notif_error);
@ -539,7 +561,7 @@ static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_
    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);

-    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 */
@ -591,11 +613,11 @@ static void chat_onFileRecv(ToxWindow *self, Tox *m, uint32_t friendnum, uint32_
    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,
@ -618,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);
@ -646,7 +668,7 @@ void chat_onInvite (ToxWindow *self, ToxAV *av, uint32_t friend_number, int stat
    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!");
@ -662,8 +684,10 @@ void chat_onRinging (ToxWindow *self, ToxAV *av, uint32_t friend_number, int sta
    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 */
 }

@ -770,33 +794,6 @@ void chat_onEnd (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 #endif /* SOUND_NOTIFY */
 }

-void chat_onRequestTimeout (ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
-{
-    if (!self || self->num != friend_number)
-        return;
-
-    self->is_call = false;
-    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, uint32_t friend_number, int state)
-{
-    if (!self || self->num != friend_number)
-        return;
-
-    self->is_call = false;
-    kill_infobox(self);
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Peer disconnected; call ended!");
-
-#ifdef SOUND_NOTIFY
-    stop_sound(self->ringing_sound);
-#endif /* SOUND_NOTIFY */
-}
-
 static void init_infobox(ToxWindow *self)
 {
    ChatContext *ctx = self->chatwin;
@ -843,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)
@ -880,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 */
@ -899,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;

@ -916,12 +912,15 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
    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)
@ -943,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 {
@ -963,38 +971,41 @@ static void chat_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
            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);
@ -1041,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;
@ -1116,13 +1129,14 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
    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)
--- a/src/chat_commands.c
+++ b/src/chat_commands.c
@ -92,8 +92,10 @@ void cmd_groupinvite(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*a
        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;
    }

@ -116,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,
-                                           NULL, 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;
    }

@ -190,6 +191,7 @@ void cmd_savefile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
    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.");
@ -258,7 +260,7 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv

    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);
+                                     (uint8_t *) file_name, namelen, &err);

    if (err != TOX_ERR_FILE_SEND_OK)
        goto on_send_error;
@ -282,6 +284,7 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
    return;

 on_send_error:
+
    switch (err) {
        case TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND:
            errmsg = "File transfer failed: Invalid friend.";
--- a/src/chat_commands.h
+++ b/src/chat_commands.h
@ -41,6 +41,7 @@ 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
--- a/src/configdir.c
+++ b/src/configdir.c
@ -33,7 +33,7 @@
 #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;
@ -99,16 +99,13 @@ char *get_user_config_dir(void)

 # endif /* __APPLE__ */

-    if (!file_exists(user_config_dir)) {
-        free(user_config_dir);
-        return NULL;
-    }
-
    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)
 {
--- a/src/configdir.h
+++ b/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 */
--- a/src/curl_util.c
+++ b/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;
+}
--- a/src/curl_util.h
+++ b/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 */
--- a/src/execute.c
+++ b/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;
@ -65,8 +66,11 @@ static struct cmd_func global_commands[] = {
 #endif /* AUDIO */
 #ifdef VIDEO
    { "/lsvdev",    cmd_list_video_devices },
-    { "/svdev" ,    cmd_change_video_device },
+    { "/svdev",    cmd_change_video_device },
 #endif /* VIDEO */
+#ifdef PYTHON
+    { "/run",       cmd_run           },
+#endif /* PYTHON */
    { NULL,         NULL              },
 };

@ -83,6 +87,7 @@ 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       },
@ -186,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.");
 }
--- a/src/file_transfers.c
+++ b/src/file_transfers.c
@ -38,87 +38,48 @@ extern FriendsList Friends;
 /* number of "#"'s in file transfer progress bar. Keep well below MAX_STR_SIZE */
 #define NUM_PROG_MARKS 50

-/* Checks for timed out file transfers and closes them. */
-#define CHECK_FILE_TIMEOUT_INTERAVAL 5
-void check_file_transfer_timeouts(Tox *m)
-{
-    char msg[MAX_STR_SIZE];
-    static uint64_t last_check = 0;
-
-    if (!timed_out(last_check, CHECK_FILE_TIMEOUT_INTERAVAL))
-        return;
-
-    last_check = get_unix_time();
-
-    size_t i, j;
-
-    for (i = 0; i < Friends.max_idx; ++i) {
-        if (!Friends.list[i].active)
-            continue;
-
-        for (j = 0; j < MAX_FILES; ++j) {
-            struct FileTransfer *ft_send = &Friends.list[i].file_sender[j];
-
-            if (ft_send->state > FILE_TRANSFER_PAUSED) {
-                if (timed_out(ft_send->last_keep_alive, TIMEOUT_FILESENDER)) {
-                    snprintf(msg, sizeof(msg), "File transfer for '%s' timed out.", ft_send->file_name);
-                    close_file_transfer(ft_send->window, m, ft_send, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
-                }
-            }
-
-            struct FileTransfer *ft_recv = &Friends.list[i].file_receiver[j];
-
-            if (ft_recv->state > FILE_TRANSFER_PAUSED) {
-                if (timed_out(ft_recv->last_keep_alive, TIMEOUT_FILESENDER)) {
-                    snprintf(msg, sizeof(msg), "File transfer for '%s' timed out.", ft_recv->file_name);
-                    close_file_transfer(ft_recv->window, m, ft_recv, TOX_FILE_CONTROL_CANCEL, msg, notif_error);
-                }
-            }
-        }
-    }
-}
-
 /* creates initial progress line that will be updated during file transfer.
-   Assumes progline is of size MAX_STR_SIZE */
+   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)
 {
    if (bps < 0 || pct_done < 0 || pct_done > 100)
        return;

-    char msg[MAX_STR_SIZE];
-    bytes_convert_str(msg, sizeof(msg), bps);
-    strcat(msg, "/s [");
+    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);
 }

 static void refresh_progress_helper(ToxWindow *self, Tox *m, struct FileTransfer *ft)
@ -175,7 +136,7 @@ struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filen
 * Returns NULL on failure.
 */
 struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t index,
-                                                    FILE_TRANSFER_DIRECTION direction)
+        FILE_TRANSFER_DIRECTION direction)
 {
    if (direction != FILE_TRANSFER_RECV && direction != FILE_TRANSFER_SEND)
        return NULL;
@ -184,8 +145,8 @@ struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t

    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];
+                                      &Friends.list[friendnum].file_sender[i] :
+                                      &Friends.list[friendnum].file_receiver[i];

        if (ft->state != FILE_TRANSFER_INACTIVE && ft->index == index)
            return ft;
--- a/src/file_transfers.h
+++ b/src/file_transfers.h
@ -34,7 +34,6 @@
 #define GiB 1073741824    /* 1024^3 */

 #define MAX_FILES 32
-#define TIMEOUT_FILESENDER 120

 typedef enum FILE_TRANSFER_STATE {
    FILE_TRANSFER_INACTIVE,
@ -62,15 +61,12 @@ struct FileTransfer {
    size_t   index;
    uint64_t file_size;
    uint64_t position;
-    uint64_t last_line_progress;   /* The last time we updated the progress bar */
-    uint64_t last_keep_alive;  /* The last time we sent or received data */
+    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];
 };

-/* Checks for timed out file transfers and closes them. */
-void check_file_transfer_timeouts(Tox *m);
-
 /* creates initial progress line that will be updated during file transfer.
   progline must be at lesat MAX_STR_SIZE bytes */
 void init_progress_bar(char *progline);
@ -91,7 +87,7 @@ struct FileTransfer *get_file_transfer_struct(uint32_t friendnum, uint32_t filen
 * Returns NULL on failure.
 */
 struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnum, uint32_t index,
-                                                    FILE_TRANSFER_DIRECTION direction);
+        FILE_TRANSFER_DIRECTION direction);

 /* Initializes an unused file transfer and returns its pointer.
 * Returns NULL on failure.
--- a/src/friendlist.c
+++ b/src/friendlist.c
@ -133,23 +133,34 @@ void kill_friendlist(void)
 #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[len];
+    char *data = malloc(len * sizeof(char));
+
+    if (data == NULL) {
+        return -1;
+    }

    int i, count = 0;

    for (i = 0; i < Blocked.max_idx; ++i) {
-        if (count > Blocked.num_blocked)
+        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)];
@ -164,8 +175,11 @@ static int save_blocklist(char *path)

    /* Blocklist is empty, we can remove the empty file */
    if (count == 0) {
-        if (remove(path) != 0)
+        free(data);
+
+        if (remove(path) != 0) {
            return -1;
+        }

        return 0;
    }
@ -175,19 +189,24 @@ static int save_blocklist(char *path)

    FILE *fp = fopen(temp_path, "wb");

-    if (fp == NULL)
+    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);

-    if (rename(temp_path, path) != 0)
+    if (rename(temp_path, path) != 0) {
        return -1;
+    }

    return 0;
 }
@ -235,10 +254,15 @@ int load_blocklist(char *path)
        memset(&Blocked.list[i], 0, sizeof(BlockedFriend));

        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 = MIN(TOXIC_MAX_NAME_LENGTH, 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)];
@ -299,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;
@ -424,7 +448,7 @@ void friendlist_onFriendAdded(ToxWindow *self, Tox *m, uint32_t num, bool sort)
            fprintf(stderr, "tox_friend_get_public_key failed (error %d)\n", pkerr);

        TOX_ERR_FRIEND_GET_LAST_ONLINE loerr;
-        uint64_t t = tox_friend_get_last_online(m, num, &loerr);
+        time_t t = tox_friend_get_last_online(m, num, &loerr);

        if (loerr != TOX_ERR_FRIEND_GET_LAST_ONLINE_OK)
            t = 0;
@ -523,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);
 }
@ -545,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;
@ -630,16 +655,18 @@ static void draw_del_popup(void)
    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 */
@ -757,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;

@ -784,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:
@ -796,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;
    }
 }
@ -866,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)
@ -895,7 +924,7 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
        return;
    }

-    uint64_t cur_time = time(NULL);
+    time_t cur_time = get_unix_time();
    struct tm cur_loc_tm = *localtime((const time_t *) &cur_time);

    wattron(self->window, A_BOLD);
@ -955,9 +984,11 @@ static void friendlist_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;
@ -1032,16 +1063,16 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
                    wattroff(self->window, COLOR_PAIR(BLUE));

                pthread_mutex_lock(&Winthread.lock);
-                uint64_t last_seen = Friends.list[f].last_online.last_on;
+                time_t last_seen = Friends.list[f].last_online.last_on;
                pthread_mutex_unlock(&Winthread.lock);

                if (last_seen != 0) {
                    pthread_mutex_lock(&Winthread.lock);

                    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)
-                    );
+                                       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;

                    pthread_mutex_unlock(&Winthread.lock);
@ -1081,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)
@ -1097,7 +1128,8 @@ void disable_chatwin(uint32_t f_num)
 static void friendlist_onAV(ToxWindow *self, ToxAV *av, uint32_t friend_number, int state)
 {
    assert(0);
-    if( friend_number >= Friends.max_idx)
+
+    if ( friend_number >= Friends.max_idx)
        return;

    assert(0);
@ -1105,7 +1137,7 @@ static void friendlist_onAV(ToxWindow *self, ToxAV *av, uint32_t friend_number,

    if (Friends.list[friend_number].chatwin == -1) {
        if (get_num_active_windows() < MAX_WINDOWS_NUM) {
-            if(state != TOXAV_FRIEND_CALL_STATE_FINISHED) {
+            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);
            }
--- a/src/friendlist.h
+++ b/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];
@ -65,7 +65,7 @@ typedef struct {

 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;
--- a/src/global_commands.c
+++ b/src/global_commands.c
@ -36,6 +36,7 @@
 #include "avatars.h"
 #include "name_lookup.h"
 #include "qr_code.h"
+#include "toxic_strings.h"

 extern char *DATA_FILE;
 extern ToxWindow *prompt;
@ -129,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.";
@ -259,6 +261,7 @@ void cmd_connect(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
    }

    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;
@ -280,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;
    }
@ -332,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, NULL, 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;
    }

@ -447,25 +451,42 @@ void cmd_myqr(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
    char dir[data_file_len + 1];
    size_t dir_len = get_base_dir(DATA_FILE, data_file_len, dir);

-    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);
+#ifdef QRPNG

-    FILE *output = fopen(qr_path, "wb");
+    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")) {

-    if (output == NULL) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to create QR code.");
+#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;
    }

-    if (ID_to_QRcode(id_string, output) == -1) {
-        fclose(output);
-        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);
-
-    fclose(output);
+#endif /* QRPNG */
 }

 void cmd_nick(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@ -513,22 +534,39 @@ 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])
 {
-    uint32_t nospam = rand();   /* should be random enough */
-    tox_self_set_nospam(m, nospam);
-    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Your Tox ID has been changed to:");
+    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, "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, "");
+    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])
@ -617,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:
--- a/src/global_commands.h
+++ b/src/global_commands.h
@ -56,4 +56,8 @@ void cmd_list_video_devices(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)
 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 */
--- a/src/group_commands.c
+++ b/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;
    }

--- a/src/groupchat.c
+++ b/src/groupchat.c
@ -69,8 +69,12 @@ static int max_groupchat_index = 0;
 extern struct user_settings *user_settings;
 extern struct Winthread Winthread;

-#ifdef AUDIO
+#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 20
 #endif /* AUDIO */
@ -98,25 +102,18 @@ static const char group_cmd_list[AC_NUM_GROUP_COMMANDS][MAX_CMDNAME_SIZE] = {
    { "/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;
@ -135,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)
@ -174,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);
@ -237,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;
@ -258,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);
@ -266,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;

@ -341,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);
@ -351,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);
@ -385,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;
 };
@ -429,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;
@ -437,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;
@ -446,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';
@ -482,7 +440,7 @@ static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnu
    get_time_str(timefrmt, sizeof(timefrmt));

    switch (change) {
-        case TOX_CHAT_CHANGE_PEER_ADD:
+        case TOX_CONFERENCE_STATE_CHANGE_PEER_JOIN:
            if (!timed_out(groupchats[groupnum].start_time, GROUP_EVENT_WAIT))
                break;

@ -512,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);

@ -522,7 +480,7 @@ 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:
+        case TOX_CONFERENCE_STATE_CHANGE_PEER_NAME_CHANGE:
            if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT))
                return;

@ -549,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);
    }
 }

@ -571,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;
    }
@ -592,7 +554,16 @@ 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);
            }

@ -615,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);
+                }
            }
        }

@ -676,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);
@ -691,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);
@ -709,7 +693,7 @@ static void groupchat_onDraw(ToxWindow *self, Tox *m)
    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);
@ -751,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, uint32_t 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));
@ -882,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));
--- a/src/groupchat.h
+++ b/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 */
--- a/src/help.c
+++ b/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)
@ -95,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));
@ -112,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)
@ -154,11 +169,15 @@ static void help_draw_global(ToxWindow *self)
    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                    : Change part of your Tox ID to stop spam\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");
@ -181,10 +200,18 @@ static void help_draw_global(ToxWindow *self)
    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)
@ -215,6 +242,7 @@ 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
@ -227,7 +255,7 @@ static void help_draw_chat(ToxWindow *self)
    help_draw_bottom_menu(win);

    box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    wnoutrefresh(win);
 }

 static void help_draw_keys(ToxWindow *self)
@ -245,13 +273,15 @@ static void help_draw_keys(ToxWindow *self)
    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)
@ -269,9 +299,29 @@ static void help_draw_group(ToxWindow *self)
    help_draw_bottom_menu(win);

    box(win, ACS_VLINE, ACS_HLINE);
-    wrefresh(win);
+    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);
+    wnoutrefresh(win);
+}
+#endif
+
 static void help_draw_contacts(ToxWindow *self)
 {
    WINDOW *win = self->help->win;
@ -291,12 +341,14 @@ 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);
@ -304,9 +356,9 @@ void help_onKey(ToxWindow *self, wint_t key)

        case 'c':
 #ifdef VIDEO
-            help_init_window(self, 22, 80);
+            help_init_window(self, 23, 80);
 #elif AUDIO
-            help_init_window(self, 19, 80);
+            help_init_window(self, 20, 80);
 #else
            help_init_window(self, 10, 80);
 #endif
@ -314,13 +366,16 @@ void help_onKey(ToxWindow *self, wint_t key)
            break;

        case 'g':
+            height = 22;
 #ifdef VIDEO
-            help_init_window(self, 30, 80);
+            height += 8;
 #elif AUDIO
-            help_init_window(self, 26, 80);
-#else
-            help_init_window(self, 22, 80);
+            height += 4;
 #endif
+#ifdef PYTHON
+            height += 2;
+#endif
+            help_init_window(self, height, 80);
            self->help->type = HELP_GLOBAL;
            break;

@ -329,13 +384,21 @@ void help_onKey(ToxWindow *self, wint_t key)
            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':
            help_init_window(self, 10, 80);
            self->help->type = HELP_CONTACTS;
            break;

        case 'k':
-            help_init_window(self, 13, 80);
+            help_init_window(self, 15, 80);
            self->help->type = HELP_KEYS;
            break;

@ -348,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;
@ -374,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 */
    }
 }
--- a/src/help.h
+++ b/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);
--- a/src/input.c
+++ b/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;
@ -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;
 }
--- a/src/line_info.c
+++ b/src/line_info.c
@ -129,17 +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;
+        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));

@ -158,12 +162,14 @@ 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;
@ -220,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;
@ -228,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() */
@ -242,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);
@ -304,8 +313,10 @@ 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));
@ -323,17 +334,27 @@ 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));
-                else if (line->msg[0] == '<')
-                    wattron(win, COLOR_PAIR(RED));
+                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));
-                else if (line->msg[0] == '<')
-                    wattroff(win, COLOR_PAIR(RED));
+                    if (line[0] == '>')
+                        wattron(win, COLOR_PAIR(GREEN));
+                    else if (line[0] == '<')
+                        wattron(win, COLOR_PAIR(RED));
+
+                    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));
@ -350,8 +371,10 @@ void line_info_print(ToxWindow *self)
                break;

            case OUT_ACTION_READ:
+
            /* fallthrough */
            case OUT_ACTION:
+
            /* fallthrough */
            case IN_ACTION:
                wattron(win, COLOR_PAIR(BLUE));
@ -538,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;
    }

--- a/src/line_info.h
+++ b/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);
--- a/src/log.c
+++ b/src/log.c
@ -262,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);

--- a/src/log.h
+++ b/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 */
 };
--- a/src/message_queue.c
+++ b/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)
--- a/src/message_queue.h
+++ b/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);
--- a/src/misc_tools.c
+++ b/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,19 +57,13 @@ void hst_to_net(uint8_t *num, uint16_t numbytes)
    return;
 }

-/* Note: The time functions are not thread safe */
-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 timeout)
+int timed_out(time_t timestamp, time_t timeout)
 {
    return timestamp + timeout <= get_unix_time();
 }
@ -75,8 +72,8 @@ int timed_out(uint64_t timestamp, uint64_t timeout)
 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;
 }

@ -93,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;
@ -162,7 +159,7 @@ int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_
    size_t i;

    for (i = 0; i < TOX_ADDRESS_SIZE; ++i)
-        snprintf(&output[i*2], output_size - (i * 2), "%02X", bin_id[i] & 0xff);
+        snprintf(&output[i * 2], output_size - (i * 2), "%02X", bin_id[i] & 0xff);

    return 0;
 }
@ -176,6 +173,15 @@ int string_is_empty(const char *string)
    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)
 {
@ -184,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;
@ -198,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;
@ -225,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;
    }
@ -316,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) {
@ -372,9 +408,13 @@ int char_find(int idx, const char *s, char ch)
 }

 /* returns index of the last instance of ch in s starting at len.
-   returns 0 if char not found (skips 0th index). */
+   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) {
@ -461,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;
+}
--- a/src/misc_tools.h
+++ b/src/misc_tools.h
@ -61,23 +61,23 @@ int hex_string_to_bytes(char *buf, int size, const char *keystr);
 int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_t output_size);

 /* get the current unix time (not thread safe) */
-uint64_t get_unix_time(void);
+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 (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);

@ -88,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);
+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);
@ -126,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 */
@ -158,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 */
--- a/src/name_lookup.c
+++ b/src/name_lookup.c
@ -21,8 +21,8 @@
 */

 #include <stdlib.h>
+#include <stdarg.h>
 #include <string.h>
-#include <sys/types.h> /* for u_char */
 #include <curl/curl.h>

 #include "toxic.h"
@ -31,9 +31,10 @@
 #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;;
+extern struct Winthread Winthread;

 #define NAMESERVER_API_PATH "api"
 #define SERVER_KEY_SIZE 32
@ -41,9 +42,6 @@ extern struct Winthread Winthread;;
 #define MAX_DOMAIN_SIZE 32
 #define MAX_SERVER_LINE MAX_DOMAIN_SIZE + (SERVER_KEY_SIZE * 2) + 3

-/* 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"
-
 struct Nameservers {
    int     lines;
    char    names[MAX_SERVERS][MAX_DOMAIN_SIZE];
@ -56,8 +54,8 @@ static struct thread_data {
    char    id_bin[TOX_ADDRESS_SIZE];
    char    addr[MAX_STR_SIZE];
    char    msg[MAX_STR_SIZE];
-    bool    busy;
    bool    disabled;
+    volatile bool busy;
 } t_data;

 static struct lookup_thread {
@ -189,40 +187,17 @@ static bool get_domain_match(char *pubkey, char *out_domain, size_t out_domain_s
    return false;
 }

-#define MAX_RECV_LOOKUP_DATA_SIZE 1024
-
-/* Holds raw data received from name server */
-struct Recv_Data {
-    char data[MAX_RECV_LOOKUP_DATA_SIZE];
-    size_t size;
-};
-
-size_t write_lookup_data(void *data, size_t size, size_t nmemb, void *user_pointer)
-{
-    struct Recv_Data *recv_data = (struct Recv_Data *) user_pointer;
-    size_t real_size = size * nmemb;
-
-    if (real_size >= MAX_RECV_LOOKUP_DATA_SIZE)
-        return 0;
-
-    memcpy(&recv_data->data, data, real_size);
-    recv_data->size = real_size;
-    recv_data->data[real_size] = '\0';
-
-    return real_size;
-}
-
 /* 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_Data *recv_data)
+static int process_response(struct Recv_Curl_Data *recv_data)
 {
    size_t prefix_size = strlen(ID_PREFIX);

-    if (recv_data->size < TOX_ADDRESS_SIZE * 2 + prefix_size)
+    if (recv_data->length < TOX_ADDRESS_SIZE * 2 + prefix_size)
        return -1;

    const char *IDstart = strstr(recv_data->data, ID_PREFIX);
@ -243,47 +218,6 @@ static int process_response(struct Recv_Data *recv_data)
    return 0;
 }

-/* Sets proxy info for given CURL handler.
- *
- * Returns 0 on success or if no proxy is set by the client.
- * Returns -1 on failure.
- */
-static int set_lookup_proxy(ToxWindow *self, 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) {
-        lookup_error(self, "Unknown proxy error");
-        return -1;
-    }
-
-    int ret = curl_easy_setopt(c_handle, CURLOPT_PROXYPORT, (long) port);
-
-    if (ret != CURLE_OK) {
-        lookup_error(self, "Failed to set proxy port (libcurl error %d)", ret);
-        return -1;
-    }
-
-    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) {
-        lookup_error(self, "Failed to set proxy type (libcurl error %d)", ret);
-        return -1;
-    }
-
-    ret = curl_easy_setopt(c_handle, CURLOPT_PROXY, proxy_address);
-
-    if (ret != CURLE_OK) {
-        lookup_error(self, "Failed to set proxy (libcurl error %d)", ret);
-        return -1;
-    }
-
-    return 0;
-}
-
 void *lookup_thread_func(void *data)
 {
    ToxWindow *self = t_data.self;
@ -301,7 +235,7 @@ void *lookup_thread_func(void *data)

    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");
+            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.");

@ -315,26 +249,38 @@ void *lookup_thread_func(void *data)
        kill_lookup_thread();
    }

-    struct Recv_Data recv_data;
-    memset(&recv_data, 0, sizeof(struct Recv_Data));
+    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, write_lookup_data);
-    curl_easy_setopt(c_handle, CURLOPT_WRITEDATA, (void *) &recv_data);
+
+    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);

-    if (set_lookup_proxy(self, c_handle, arg_opts.proxy_address, arg_opts.proxy_port, arg_opts.proxy_type) == -1)
+    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);

@ -437,9 +383,9 @@ void name_lookup(ToxWindow *self, Tox *m, const char *id_bin, const char *addr,
 * 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(void)
+int name_lookup_init(int curl_init_status)
 {
-    if (curl_global_init(CURL_GLOBAL_ALL) != 0) {
+    if (curl_init_status != 0) {
        t_data.disabled = true;
        return -1;
    }
@ -454,8 +400,3 @@ int name_lookup_init(void)

    return 0;
 }
-
-void name_lookup_cleanup(void)
-{
-    curl_global_cleanup();
-}
--- a/src/name_lookup.h
+++ b/src/name_lookup.h
@ -29,8 +29,7 @@
 * Returns 0 on success.
 * Returns -1 on failure.
 */
-int name_lookup_init(void);
-void name_lookup_cleanup(void);
+int name_lookup_init(int curl_init_status);

 int name_lookup(ToxWindow *self, Tox *m, const char *id_bin, const char *addr, const char *message);

--- a/src/notify.c
+++ b/src/notify.c
@ -38,24 +38,24 @@
 #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,7 +88,7 @@ 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[64];
    size_t size;
@ -188,15 +188,17 @@ void graceful_clear()

        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 ) {
@ -221,11 +223,11 @@ void graceful_clear()
    control_unlock();
 }

-void* do_playing(void* _p)
+void *do_playing(void *_p)
 {
    (void)_p;

-    while(true) {
+    while (true) {
        control_lock();

        if (!Control.poll_active) {
@ -234,65 +236,73 @@ void* do_playing(void* _p)
        }

        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 && time(NULL) >= 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 &&
-           (time(NULL) - 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 */
    }
@ -308,11 +318,11 @@ 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;

-    while(true) {
+    while (true) {
        control_lock();

        if (!Control.poll_active) {
@ -323,20 +333,22 @@ void* do_playing(void* _p)
        int i;

        for (i = 0; i < ACTIVE_NOTIFS_MAX; i ++) {
-            if (actives[i].box && time(NULL) >= 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);
 }

@ -347,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;
        }
@ -378,6 +390,7 @@ 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;

@ -419,7 +432,9 @@ void terminate_notify()

 #ifdef SOUND_NOTIFY
    int i = 0;
+
    for (; i < SOUNDS_SIZE; i ++) free(Control.sounds[i]);
+
    alutExit();
 #endif /* SOUND_NOTIFY */

@ -429,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;

@ -457,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;
    }

@ -472,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;

@ -487,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));
    }
 }
@ -508,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();

@ -516,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);

@ -540,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 */
@ -558,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);

@ -566,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();

@ -578,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);
@ -593,6 +616,7 @@ int sound_notify2(ToxWindow* self, Notification notif, uint64_t flags, int id)

    return id;
 #else
+
    if (notif != silent)
        beep();

@ -600,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);
@ -614,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 */
@ -624,17 +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;
    }
+
 #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__);

@ -657,7 +690,7 @@ int box_notify(ToxWindow* self, Notification notif, uint64_t flags, int* id_indi
 #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);
@ -676,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__);

@ -689,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");
    }
@ -707,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);

@ -719,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 */
@ -731,9 +768,11 @@ int box_silent_notify(ToxWindow* self, uint64_t flags, int* id_indicator, const
    }

    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__);

@ -757,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);

@ -773,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__);

@ -786,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");
    }
--- a/src/notify.h
+++ b/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 */
--- a/src/osx_video.h
+++ b/src/osx_video.h
@ -31,13 +31,16 @@
 #endif /* __OBJC__ */

 #define RELEASE_CHK(func, obj) if ((obj))\
- 	func((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;
+@interface OSXVideo :
+    NSObject <AVCaptureVideoDataOutputSampleBufferDelegate>
+- (instancetype)initWithDeviceNames:
+    (char **)device_names AmtDevices:
+    (int *)size;
@end
 #endif /* __OBJC__ */

--- a/src/osx_video.m
+++ b/src/osx_video.m
@ -44,19 +44,19 @@
 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;
+    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;
+    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;
+    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)
@ -65,9 +65,10 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
    uint8_t *p;
    uint8_t r, g, b;

-    for(y = 0; y != height; y += 2) {
+    for (y = 0; y != height; y += 2) {
        p = rgb;
-        for(x = 0; x != width; x++) {
+
+        for (x = 0; x != width; x++) {
            b = *rgb++;
            g = *rgb++;
            r = *rgb++;
@ -76,7 +77,7 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
            *plane_y++ = rgb_to_y(r, g, b);
        }

-        for(x = 0; x != width / 2; x++) {
+        for (x = 0; x != width / 2; x++) {
            b = *rgb++;
            g = *rgb++;
            r = *rgb++;
@ -91,9 +92,12 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t

            *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++;
+            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);
@ -122,28 +126,34 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
    BOOL _shouldMangleDimensions;
 }

- (instancetype)initWithDeviceNames: (char **)device_names AmtDevices: (int *)size {
+- (instancetype)initWithDeviceNames:
+    (char **)device_names AmtDevices:
+    (int *)size
+{
    _session = [[AVCaptureSession alloc] init];

-    NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType: AVMediaTypeVideo];
    int i;
+
    for (i = 0; i < [devices count]; ++i) {
-        AVCaptureDevice *device = [devices objectAtIndex: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]);
+        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 {
+- (void)dealloc
+{
    pthread_mutex_destroy(&_frameLock);
    [_session release];
    [_linkerVideo release];
@ -151,14 +161,18 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
    [super dealloc];
 }

- (int)openVideoDeviceIndex: (uint32_t)device_idx Width: (uint16_t *)width Height: (uint16_t *)height {
+- (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];
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType: AVMediaTypeVideo];
+    AVCaptureDevice *device = [devices objectAtIndex: device_idx];
    NSError *error = NULL;
-    AVCaptureInput *input = [[AVCaptureDeviceInput alloc] initWithDevice:device error:&error];
+    AVCaptureInput *input = [[AVCaptureDeviceInput alloc] initWithDevice: device error: &error];

    if ( error != NULL ) {
        [input release];
@ -166,7 +180,7 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
    }

    [_session beginConfiguration];
-    [_session addInput:input];
+    [_session addInput: input];
    //_session.sessionPreset = AVCaptureSessionPreset640x480;
    //*width = 640;
    //*height = 480;
@ -176,8 +190,9 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
    [device release];

    /* Obtain device resolution */
-    AVCaptureInputPort *port = [input.ports objectAtIndex:0];
+    AVCaptureInputPort *port = [input.ports objectAtIndex: 0];
    CMFormatDescriptionRef format_description = port.formatDescription;
+
    if ( format_description ) {
        CMVideoDimensions dimensions = CMVideoFormatDescriptionGetDimensions(format_description);
        *width = dimensions.width;
@ -188,36 +203,47 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
    }

    _linkerVideo = [[AVCaptureVideoDataOutput alloc] init];
-    [_linkerVideo setSampleBufferDelegate:self queue:_processingQueue];
+    [_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}];
+        [_linkerVideo setVideoSettings: @ {
+             (id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA),
+             (id)kCVPixelBufferWidthKey: @640,
+             (id)kCVPixelBufferHeightKey: @480
+                     }];
    } else {
-        [_linkerVideo setVideoSettings:@{(id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)}];
+        [_linkerVideo setVideoSettings: @ {(id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)}];
    }
-    [_session addOutput:_linkerVideo];
+
+    [_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];
+- (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];
+    AVCaptureInput *input = [[AVCaptureDeviceInput alloc] initWithDevice: device error: &error];
    [_session stopRunning];
-    [_session removeOutput:_linkerVideo];
-    [_session removeInput:input];
+    [_session removeOutput: _linkerVideo];
+    [_session removeInput: input];
    [_linkerVideo release];
 }

- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection {
+- (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 {
@ -228,10 +254,17 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
        // 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 {
+- (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;
    }
@ -240,6 +273,7 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
    CFRetain(_currentFrame);

    CFTypeID imageType = CFGetTypeID(_currentFrame);
+
    if (imageType == CVPixelBufferGetTypeID()) {
        // TODO maybe handle other formats
        bgrxtoyuv420(y, u, v, CVPixelBufferGetBaseAddress(_currentFrame), *width, *height);
@ -263,7 +297,7 @@ void bgrxtoyuv420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v, uint8_t
 /*
 * C-interface for OSXVideo
 */
-static OSXVideo* _OSXVideo = nil;
+static OSXVideo *_OSXVideo = nil;

 int osx_video_init(char **device_names, int *size)
 {
--- a/src/prompt.c
+++ b/src/prompt.c
@ -49,10 +49,16 @@ extern struct Winthread Winthread;

 extern FriendsList Friends;
 FriendRequests FrndRequests;
-#ifdef VIDEO
+#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 18
 #endif
@ -92,6 +98,12 @@ static const char glob_cmd_list[AC_NUM_GLOB_COMMANDS][MAX_CMDNAME_SIZE] = {

 #endif /* VIDEO */

+#ifdef PYTHON
+
+    { "/run"         },
+
+#endif /* PYTHON */
+
 };

 void kill_prompt_window(ToxWindow *self)
@ -189,13 +201,16 @@ static void prompt_onKey(ToxWindow *self, Tox *m, wint_t key, bool ltr)
    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;
    }
@ -211,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
@ -232,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);
@ -295,10 +319,12 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
                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;
@ -329,7 +355,7 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)

        pthread_mutex_lock(&Winthread.lock);
        size_t slen = tox_self_get_status_message_size(m);
-        tox_self_get_status_message (m, (uint8_t*) statusmsg);
+        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);
@ -363,13 +389,13 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
    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)
 {
    ChatContext *ctx = self->chatwin;

@ -383,6 +409,10 @@ static void prompt_onConnectionChange(ToxWindow *self, Tox *m, uint32_t friendnu
    get_time_str(timefrmt, sizeof(timefrmt));
    const char *msg;

+    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);
@ -394,8 +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 if (connection_status == TOX_CONNECTION_NONE) {
+    } 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);
--- a/src/python_api.c
+++ b/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);
+    }
+}
--- a/src/python_api.h
+++ b/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 */
--- a/src/qr_code.c
+++ b/src/qr_code.c
@ -23,30 +23,42 @@
 #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 to the given file stream.
+/* 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(const char *tox_id, FILE *fp)
+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)
+    if (qr_obj == NULL) {
+        fclose(fp);
        return -1;
+    }

    size_t width = qr_obj->width;
    size_t i, j;
@ -83,7 +95,116 @@ int ID_to_QRcode(const char *tox_id, FILE *fp)
        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 */
--- a/src/qr_code.h
+++ b/src/qr_code.h
@ -25,11 +25,21 @@

 #define QRCODE_FILENAME_EXT ".QRcode"

-/* Converts a tox ID string into a QRcode and prints it to the given file stream.
+/* 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(const char *tox_id, FILE *fp);
+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 */
--- a/src/settings.c
+++ b/src/settings.c
@ -32,39 +32,45 @@
 #include "misc_tools.h"

 #ifdef AUDIO
-    #include "audio_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);
--- a/src/settings.h
+++ b/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,
--- a/src/term_mplex.c
+++ b/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,6 +168,7 @@ static int detect_gnu_screen ()
    session_info_stream = NULL;

    socket_path = extract_socket_path (dyn_buffer);
+
    if (!socket_path)
        goto nomplex;

@ -181,28 +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 */
-    snprintf (mplex_data, sizeof(mplex_data), "%s", pos + 1);
+    /* store the session id for later use */
+    snprintf (mplex_data, sizeof(mplex_data), "$%s", pos + 1);
    mplex = MPLEX_TMUX;
    return 1;
 }
@ -230,6 +243,7 @@ static int gnu_screen_is_detached ()
        return 0;

    struct stat sb;
+
    if (stat (mplex_data, &sb) != 0)
        return 0;

@ -238,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)
@ -253,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;

@ -268,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);
@ -282,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;
@ -292,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;
 }

@ -332,26 +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);
        size_t slen = tox_self_get_status_message_size(m);
-        tox_self_get_status_message (m, (uint8_t*) prev_note);
+        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];
--- a/src/toxic.c
+++ b/src/toxic.c
@ -26,6 +26,7 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdarg.h>
 #include <signal.h>
 #include <locale.h>
 #include <string.h>
@ -39,7 +40,9 @@
 #include <unistd.h>
 #include <limits.h>
 #include <termios.h>
+#include <ctype.h>

+#include <curl/curl.h>
 #include <tox/tox.h>
 #include <tox/toxencryptsave.h>

@ -59,9 +62,10 @@
 #include "execute.h"
 #include "term_mplex.h"
 #include "name_lookup.h"
+#include "bootstrap.h"

 #ifdef X11
-    #include "xtra.h"
+#include "xtra.h"
 #endif

 #ifdef AUDIO
@ -72,8 +76,13 @@
 ToxAV *av;
 #endif /* AUDIO */

+#ifdef PYTHON
+#include "api.h"
+#include "python_api.h"
+#endif
+
 #ifndef PACKAGE_DATADIR
-    #define PACKAGE_DATADIR "."
+#define PACKAGE_DATADIR "."
 #endif

 /* Export for use in Callbacks */
@ -101,9 +110,17 @@ static struct user_password {
    int len;
 } user_password;

+static time_t last_signal_time;
+
 static void catch_SIGINT(int sig)
 {
-    Winthread.sig_exit_toxic = 1;
+    time_t cur_time = get_unix_time();
+
+    if (difftime(cur_time, last_signal_time) <= 1) {
+        Winthread.sig_exit_toxic = 1;
+    } else {
+        last_signal_time = cur_time;
+    }
 }

 static void catch_SIGSEGV(int sig)
@ -159,10 +176,14 @@ void exit_toxic_success(Tox *m)
    terminate_audio();
 #endif /* AUDIO */

+#ifdef PYTHON
+    terminate_python();
+#endif /* PYTHON */
+
    free_global_data();
    tox_kill(m);
    endwin();
-    name_lookup_cleanup();
+    curl_global_cleanup();

 #ifdef X11
    /* We have to terminate xtra last coz reasons
@ -199,6 +220,7 @@ static void init_term(void)
    cbreak();
    keypad(stdscr, 1);
    noecho();
+    nonl();
    timeout(100);

    if (has_colors()) {
@ -278,153 +300,6 @@ static void print_init_messages(ToxWindow *toxwin)
        line_info_add(toxwin, NULL, NULL, NULL, SYS_MSG, 0, 0, init_messages.msgs[i]);
 }

-#define MIN_NODE_LINE  50 /* IP: 7 + port: 5 + key: 38 + spaces: 2 = 70. ! (& e.g. tox.chat = 8) */
-#define MAX_NODE_LINE  256 /* Approx max number of chars in a sever line (name + port + key) */
-#define MAXNODES 50
-#define NODELEN (MAX_NODE_LINE - TOX_PUBLIC_KEY_SIZE - 7)
-
-static struct toxNodes {
-    int lines;
-    char nodes[MAXNODES][NODELEN];
-    uint16_t ports[MAXNODES];
-    char keys[MAXNODES][TOX_PUBLIC_KEY_SIZE];
-} toxNodes;
-
-static int load_nodelist(const char *filename)
-{
-    if (!filename)
-        return 1;
-
-    FILE *fp = fopen(filename, "r");
-
-    if (fp == NULL)
-        return 1;
-
-    char line[MAX_NODE_LINE];
-
-    while (fgets(line, sizeof(line), fp) && toxNodes.lines < MAXNODES) {
-        size_t line_len = strlen(line);
-
-        if (line_len >= MIN_NODE_LINE && line_len <= MAX_NODE_LINE) {
-            const char *name = strtok(line, " ");
-            const char *port_str = strtok(NULL, " ");
-            const char *key_ascii = strtok(NULL, " ");
-
-            if (name == NULL || port_str == NULL || key_ascii == NULL)
-                continue;
-
-            long int port = strtol(port_str, NULL, 10);
-
-            if (port <= 0 || port > MAX_PORT_RANGE)
-                continue;
-
-            size_t key_len = strlen(key_ascii);
-            size_t name_len = strlen(name);
-
-            if (key_len < TOX_PUBLIC_KEY_SIZE * 2 || name_len >= NODELEN)
-                continue;
-
-            snprintf(toxNodes.nodes[toxNodes.lines], sizeof(toxNodes.nodes[toxNodes.lines]), "%s", name);
-            toxNodes.nodes[toxNodes.lines][NODELEN - 1] = 0;
-            toxNodes.ports[toxNodes.lines] = port;
-
-            /* remove possible trailing newline from key string */
-            char real_ascii_key[TOX_PUBLIC_KEY_SIZE * 2 + 1];
-            memcpy(real_ascii_key, key_ascii, TOX_PUBLIC_KEY_SIZE * 2);
-            key_len = TOX_PUBLIC_KEY_SIZE * 2;
-            real_ascii_key[key_len] = '\0';
-
-            if (hex_string_to_bin(real_ascii_key, key_len, toxNodes.keys[toxNodes.lines], TOX_PUBLIC_KEY_SIZE) == -1)
-                continue;
-
-            toxNodes.lines++;
-        }
-    }
-
-    fclose(fp);
-
-    if (toxNodes.lines < 1)
-        return 1;
-
-    return 0;
-}
-
-/* Bootstraps and adds as TCP relay.
- * Returns 0 if both actions are successful.
- * Returns -1 otherwise.
- */
-int init_connection_helper(Tox *m, int line)
-{
-    TOX_ERR_BOOTSTRAP err;
-    tox_bootstrap(m, toxNodes.nodes[line], toxNodes.ports[line], (uint8_t *) toxNodes.keys[line], &err);
-
-    if (err != TOX_ERR_BOOTSTRAP_OK) {
-        fprintf(stderr, "Failed to bootstrap %s:%d\n", toxNodes.nodes[line], toxNodes.ports[line]);
-        return -1;
-    }
-
-    tox_add_tcp_relay(m, toxNodes.nodes[line], toxNodes.ports[line], (uint8_t *) toxNodes.keys[line], &err);
-
-    if (err != TOX_ERR_BOOTSTRAP_OK) {
-        fprintf(stderr, "Failed to add TCP relay %s:%d\n", toxNodes.nodes[line], toxNodes.ports[line]);
-        return -1;
-    }
-
-    return 0;
-}
-
-/* Connects to a random DHT node listed in the DHTnodes file
- *
- * return codes:
- * 0: success
- * 1: failed to open node file
- * 2: no line of sufficient length in node file
- * 3: failed to resolve name to IP
- * 4: nodelist file contains no acceptable line
- */
-static bool srvlist_loaded = false;
-
-#define NUM_INIT_NODES 5
-
-int init_connection(Tox *m)
-{
-    if (toxNodes.lines > 0) { /* already loaded nodelist */
-        init_connection_helper(m, rand() % toxNodes.lines);
-        return 0;
-    }
-
-    /* only once:
-     * - load the nodelist
-     * - connect to "everyone" inside
-     */
-    if (!srvlist_loaded) {
-        srvlist_loaded = true;
-        int res;
-
-        if (!arg_opts.nodes_path[0])
-            res = load_nodelist(PACKAGE_DATADIR "/DHTnodes");
-        else
-            res = load_nodelist(arg_opts.nodes_path);
-
-        if (res != 0)
-            return res;
-
-        res = 3;
-        int i;
-        int n = MIN(NUM_INIT_NODES, toxNodes.lines);
-
-        for (i = 0; i < n; ++i) {
-            if (init_connection_helper(m, rand() % toxNodes.lines) == 0)
-                res = 0;
-        }
-
-        return res;
-    }
-
-    /* empty nodelist file */
-    return 4;
-}
-
 static void load_friendlist(Tox *m)
 {
    size_t i;
@ -463,8 +338,10 @@ static int password_prompt(char *buf, int size)
    /* eat overflowed stdin and return error */
    if (buf[--len] != '\n') {
        int ch;
+
        while ((ch = getchar()) != '\n' && ch > 0)
            ;
+
        return 0;
    }

@ -472,6 +349,49 @@ static int password_prompt(char *buf, int size)
    return len;
 }

+/* Get the password from the eval command.
+ * return length of password on success, 0 on failure
+ */
+static int password_eval(char *buf, int size)
+{
+    buf[0] = '\0';
+
+    /* Run password_eval command */
+    FILE *f = popen(user_settings->password_eval, "r");
+
+    if (f == NULL) {
+        fprintf(stderr, "Executing password_eval failed\n");
+        return 0;
+    }
+
+    /* Get output from command */
+    char *ret = fgets(buf, size, f);
+
+    if (ret == NULL) {
+        fprintf(stderr, "Reading password from password_eval command failed\n");
+        pclose(f);
+        return 0;
+    }
+
+    /* Get exit status */
+    int status = pclose(f);
+
+    if (status != 0) {
+        fprintf(stderr, "password_eval command returned error %d\n", status);
+        return 0;
+    }
+
+    /* Removez whitespace or \n at end */
+    int i, len = strlen(buf);
+
+    for (i = len - 1; i > 0 && isspace(buf[i]); i--) {
+        buf[i] = 0;
+        len--;
+    }
+
+    return len;
+}
+
 /* Ask user if they would like to encrypt the data file and set password */
 static void first_time_encrypt(const char *msg)
 {
@ -480,9 +400,10 @@ static void first_time_encrypt(const char *msg)
    do {
        system("clear");
        printf("%s ", msg);
+        fflush(stdout);

        if (!strcasecmp(ch, "y\n") || !strcasecmp(ch, "n\n") || !strcasecmp(ch, "yes\n")
-            || !strcasecmp(ch, "no\n") || !strcasecmp(ch, "q\n"))
+                || !strcasecmp(ch, "no\n") || !strcasecmp(ch, "q\n"))
            break;

    } while (fgets(ch, sizeof(ch), stdin));
@ -500,6 +421,7 @@ static void first_time_encrypt(const char *msg)
        printf("Enter a new password (must be at least %d characters) ", MIN_PASSWORD_LEN);

        while (valid_password == false) {
+            fflush(stdout); // Flush all before user input
            len = password_prompt(user_password.pass, sizeof(user_password.pass));
            user_password.len = len;

@ -543,25 +465,38 @@ static void first_time_encrypt(const char *msg)
 #define TEMP_PROFILE_EXT ".tmp"
 int store_data(Tox *m, const char *path)
 {
-    if (path == NULL)
+    if (path == NULL) {
        return -1;
+    }

    char temp_path[strlen(path) + strlen(TEMP_PROFILE_EXT) + 1];
    snprintf(temp_path, sizeof(temp_path), "%s%s", path, TEMP_PROFILE_EXT);

    FILE *fp = fopen(temp_path, "wb");

-    if (fp == NULL)
+    if (fp == NULL) {
        return -1;
+    }

    size_t data_len = tox_get_savedata_size(m);
-    char data[data_len];
+    char *data = malloc(data_len * sizeof(char));
+
+    if (data == NULL) {
+        fclose(fp);
+        return -1;
+    }

    tox_get_savedata(m, (uint8_t *) data);

    if (user_password.data_is_encrypted && !arg_opts.unencrypt_data) {
        size_t enc_len = data_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
-        char enc_data[enc_len];
+        char *enc_data = malloc(enc_len * sizeof(char));
+
+        if (enc_data == NULL) {
+            fclose(fp);
+            free(data);
+            return -1;
+        }

        TOX_ERR_ENCRYPTION err;
        tox_pass_encrypt((uint8_t *) data, data_len, (uint8_t *) user_password.pass, user_password.len,
@ -570,50 +505,58 @@ int store_data(Tox *m, const char *path)
        if (err != TOX_ERR_ENCRYPTION_OK) {
            fprintf(stderr, "tox_pass_encrypt() failed with error %d\n", err);
            fclose(fp);
+            free(data);
+            free(enc_data);
            return -1;
        }

        if (fwrite(enc_data, enc_len, 1, fp) != 1) {
            fprintf(stderr, "Failed to write profile data.\n");
            fclose(fp);
+            free(data);
+            free(enc_data);
            return -1;
        }
+
+        free(enc_data);
    } else {  /* data will not be encrypted */
        if (fwrite(data, data_len, 1, fp) != 1) {
            fprintf(stderr, "Failed to write profile data.\n");
            fclose(fp);
+            free(data);
            return -1;
        }
    }

    fclose(fp);
+    free(data);

-    if (rename(temp_path, path) != 0)
+    if (rename(temp_path, path) != 0) {
        return -1;
+    }

    return 0;
 }

 static void init_tox_callbacks(Tox *m)
 {
-    tox_callback_self_connection_status(m, prompt_onSelfConnectionChange, NULL);
-    tox_callback_friend_connection_status(m, on_connectionchange, NULL);
-    tox_callback_friend_typing(m, on_typing_change, NULL);
-    tox_callback_friend_request(m, on_request, NULL);
-    tox_callback_friend_message(m, on_message, NULL);
-    tox_callback_friend_name(m, on_nickchange, NULL);
-    tox_callback_friend_status(m, on_statuschange, NULL);
-    tox_callback_friend_status_message(m, on_statusmessagechange, NULL);
-    tox_callback_friend_read_receipt(m, on_read_receipt, NULL);
-    tox_callback_group_invite(m, on_groupinvite, NULL);
-    tox_callback_group_message(m, on_groupmessage, NULL);
-    tox_callback_group_action(m, on_groupaction, NULL);
-    tox_callback_group_namelist_change(m, on_group_namelistchange, NULL);
-    tox_callback_group_title(m, on_group_titlechange, NULL);
-    tox_callback_file_recv(m, on_file_recv, NULL);
-    tox_callback_file_chunk_request(m, on_file_chunk_request, NULL);
-    tox_callback_file_recv_control(m, on_file_control, NULL);
-    tox_callback_file_recv_chunk(m, on_file_recv_chunk, NULL);
+    tox_callback_self_connection_status(m, prompt_onSelfConnectionChange);
+    tox_callback_friend_connection_status(m, on_connectionchange);
+    tox_callback_friend_typing(m, on_typing_change);
+    tox_callback_friend_request(m, on_request);
+    tox_callback_friend_message(m, on_message);
+    tox_callback_friend_name(m, on_nickchange);
+    tox_callback_friend_status(m, on_statuschange);
+    tox_callback_friend_status_message(m, on_statusmessagechange);
+    tox_callback_friend_read_receipt(m, on_read_receipt);
+    tox_callback_conference_invite(m, on_groupinvite);
+    tox_callback_conference_message(m, on_groupmessage);
+    tox_callback_conference_namelist_change(m, on_group_namelistchange);
+    tox_callback_conference_title(m, on_group_titlechange);
+    tox_callback_file_recv(m, on_file_recv);
+    tox_callback_file_chunk_request(m, on_file_chunk_request);
+    tox_callback_file_recv_control(m, on_file_control);
+    tox_callback_file_recv_chunk(m, on_file_recv_chunk);
 }

 static void init_tox_options(struct Tox_Options *tox_opts)
@ -636,7 +579,7 @@ static void init_tox_options(struct Tox_Options *tox_opts)
        tox_opts->proxy_host = arg_opts.proxy_address;
        const char *ps = tox_opts->proxy_type == TOX_PROXY_TYPE_SOCKS5 ? "SOCKS5" : "HTTP";

-        char tmp[48];
+        char tmp[sizeof(arg_opts.proxy_address) + MAX_STR_SIZE];
        snprintf(tmp, sizeof(tmp), "Using %s proxy %s : %d", ps, arg_opts.proxy_address, arg_opts.proxy_port);
        queue_init_message("%s", tmp);
    }
@ -665,14 +608,14 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW

        if (len == 0) {
            fclose(fp);
-            exit_toxic_err("failed in load_toxic", FATALERR_FILEOP);
+            exit_toxic_err("failed in load_tox", FATALERR_FILEOP);
        }

        char data[len];

        if (fread(data, sizeof(data), 1, fp) != 1) {
            fclose(fp);
-            exit_toxic_err("failed in load_toxic", FATALERR_FILEOP);
+            exit_toxic_err("failed in load_tox", FATALERR_FILEOP);
        }

        bool is_encrypted = tox_is_data_encrypted((uint8_t *) data);
@ -680,7 +623,7 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
        /* attempt to encrypt an already encrypted data file */
        if (arg_opts.encrypt_data && is_encrypted) {
            fclose(fp);
-            exit_toxic_err("failed in load_toxic", FATALERR_ENCRYPT);
+            exit_toxic_err("failed in load_tox", FATALERR_ENCRYPT);
        }

        if (arg_opts.unencrypt_data && is_encrypted)
@ -693,14 +636,25 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
                user_password.data_is_encrypted = true;

            size_t pwlen = 0;
-            system("clear");   // TODO: is this portable?
-            printf("Enter password (q to quit) ");
+            int pweval = user_settings->password_eval[0];
+
+            if (!pweval) {
+                system("clear");   // TODO: is this portable?
+                printf("Enter password (q to quit) ");
+            }

            size_t plain_len = len - TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
            char plain[plain_len];

            while (true) {
-                pwlen = password_prompt(user_password.pass, sizeof(user_password.pass));
+                fflush(stdout); // Flush before prompts so the user sees the question/message
+
+                if (pweval) {
+                    pwlen = password_eval(user_password.pass, sizeof(user_password.pass));
+                } else {
+                    pwlen = password_prompt(user_password.pass, sizeof(user_password.pass));
+                }
+
                user_password.len = pwlen;

                if (strcasecmp(user_password.pass, "q") == 0) {
@ -712,6 +666,7 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
                    system("clear");
                    sleep(1);
                    printf("Invalid password. Try again. ");
+                    pweval = 0;
                    continue;
                }

@ -736,6 +691,7 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
                    system("clear");
                    sleep(1);
                    printf("Invalid password. Try again. ");
+                    pweval = 0;
                } else {
                    fclose(fp);
                    exit_toxic_err("tox_pass_decrypt() failed", pwerr);
@ -757,7 +713,7 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
        fclose(fp);
    } else {   /* Data file does not/should not exist */
        if (file_exists(data_path))
-            exit_toxic_err("failed in load_toxic", FATALERR_FILEOP);
+            exit_toxic_err("failed in load_tox", FATALERR_FILEOP);

        tox_opts->savedata_type = TOX_SAVEDATA_TYPE_NONE;

@ -767,7 +723,7 @@ static Tox *load_tox(char *data_path, struct Tox_Options *tox_opts, TOX_ERR_NEW
            return NULL;

        if (store_data(m, data_path) == -1)
-            exit_toxic_err("failed in load_toxic", FATALERR_FILEOP);
+            exit_toxic_err("failed in load_tox", FATALERR_FILEOP);
    }

    return m;
@ -803,42 +759,17 @@ static Tox *load_toxic(char *data_path)
    return m;
 }

-#define TRY_BOOTSTRAP_INTERVAL 5
-static uint64_t last_bootstrap_time = 0;
-
-static void do_bootstrap(Tox *m)
-{
-    static int conn_err = 0;
-
-    if (!timed_out(last_bootstrap_time, TRY_BOOTSTRAP_INTERVAL))
-        return;
-
-    if (tox_self_get_connection_status(m) != TOX_CONNECTION_NONE)
-        return;
-
-    if (conn_err != 0)
-        return;
-
-    last_bootstrap_time = get_unix_time();
-    conn_err = init_connection(m);
-
-    if (conn_err != 0)
-        line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Auto-connect failed with error code %d", conn_err);
-}
-
-static void do_toxic(Tox *m, ToxWindow *prompt)
+static void do_toxic(Tox *m)
 {
    pthread_mutex_lock(&Winthread.lock);
-    update_unix_time();

    if (arg_opts.no_connect) {
        pthread_mutex_unlock(&Winthread.lock);
        return;
    }

-    tox_iterate(m);
-    do_bootstrap(m);
-    check_file_transfer_timeouts(m);
+    tox_iterate(m, NULL);
+    do_tox_connection(m);
    pthread_mutex_unlock(&Winthread.lock);
 }

@ -883,7 +814,7 @@ void *thread_cqueue(void *data)
            ToxWindow *toxwin = get_window_ptr(i);

            if (toxwin != NULL && toxwin->is_chat
-                && tox_friend_get_connection_status(m, toxwin->num, NULL) != TOX_CONNECTION_NONE)
+                    && tox_friend_get_connection_status(m, toxwin->num, NULL) != TOX_CONNECTION_NONE)
                cqueue_try_send(toxwin, m);
        }

@ -926,6 +857,13 @@ static void print_usage(void)
    fprintf(stderr, "  -t, --force-tcp          Force toxic to use a TCP connection (use with proxies)\n");
    fprintf(stderr, "  -T, --tcp-server         Act as a TCP relay server: Requires [port]\n");
    fprintf(stderr, "  -u, --unencrypt-data     Unencrypt an encrypted data file\n");
+    fprintf(stderr, "  -v, --version            Print the version\n");
+}
+
+static void print_version(void)
+{
+    fprintf(stderr, "Toxic version %s\n", TOXICVER);
+    fprintf(stderr, "Toxcore version %d.%d.%d\n", tox_version_major(), tox_version_minor(), tox_version_patch());
 }

 static void set_default_opts(void)
@ -956,10 +894,11 @@ static void parse_args(int argc, char *argv[])
        {"SOCKS5-proxy", required_argument, 0, 'p'},
        {"HTTP-proxy", required_argument, 0, 'P'},
        {"unencrypt-data", no_argument, 0, 'u'},
+        {"version", no_argument, 0, 'v'},
        {NULL, no_argument, NULL, 0},
    };

-    const char *opts_str = "4bdehotuxc:f:n:r:p:P:T:";
+    const char *opts_str = "4bdehotuxvc:f:n:r:p:P:T:";
    int opt, indexptr;
    long int port = 0;

@ -1020,10 +959,6 @@ static void parse_args(int argc, char *argv[])

            case 'n':
                snprintf(arg_opts.nodes_path, sizeof(arg_opts.nodes_path), "%s", optarg);
-
-                if (!file_exists(arg_opts.nodes_path))
-                    queue_init_message("DHTnodes file not found");
-
                break;

            case 'o':
@ -1035,10 +970,10 @@ static void parse_args(int argc, char *argv[])
                arg_opts.proxy_type = TOX_PROXY_TYPE_SOCKS5;
                snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);

-                if (++optind > argc || argv[optind-1][0] == '-')
+                if (++optind > argc || argv[optind - 1][0] == '-')
                    exit_toxic_err("Proxy error", FATALERR_PROXY);

-                port = strtol(argv[optind-1], NULL, 10);
+                port = strtol(argv[optind - 1], NULL, 10);

                if (port <= 0 || port > MAX_PORT_RANGE)
                    exit_toxic_err("Proxy error", FATALERR_PROXY);
@ -1050,10 +985,10 @@ static void parse_args(int argc, char *argv[])
                arg_opts.proxy_type = TOX_PROXY_TYPE_HTTP;
                snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);

-                if (++optind > argc || argv[optind-1][0] == '-')
+                if (++optind > argc || argv[optind - 1][0] == '-')
                    exit_toxic_err("Proxy error", FATALERR_PROXY);

-                port = strtol(argv[optind-1], NULL, 10);
+                port = strtol(argv[optind - 1], NULL, 10);

                if (port <= 0 || port > MAX_PORT_RANGE)
                    exit_toxic_err("Proxy error", FATALERR_PROXY);
@ -1086,6 +1021,10 @@ static void parse_args(int argc, char *argv[])
                arg_opts.unencrypt_data = 1;
                break;

+            case 'v':
+                print_version();
+                exit(EXIT_SUCCESS);
+
            case 'h':
            default:
                print_usage();
@ -1177,28 +1116,9 @@ static void init_default_data_files(void)
    free(user_config_dir);
 }

-#define REC_TOX_DO_LOOPS_PER_SEC 25
-
-/* Adjusts usleep value so that tox_do runs close to the recommended number of times per second */
-static useconds_t optimal_msleepval(uint64_t *looptimer, uint64_t *loopcount, uint64_t cur_time, useconds_t msleepval)
-{
-    useconds_t new_sleep = MAX(msleepval, 3);
-    ++(*loopcount);
-
-    if (*looptimer == cur_time)
-        return new_sleep;
-
-    if (*loopcount != REC_TOX_DO_LOOPS_PER_SEC)
-        new_sleep *= (double) *loopcount / REC_TOX_DO_LOOPS_PER_SEC;
-
-    *looptimer = cur_time;
-    *loopcount = 0;
-    return new_sleep;
-}
-
 // this doesn't do anything (yet)
 #ifdef X11
-void DnD_callback(const char* asdv, DropType dt)
+void DnD_callback(const char *asdv, DropType dt)
 {
    // if (dt != DT_plain)
    //     return;
@ -1230,9 +1150,6 @@ int main(int argc, char **argv)

    bool datafile_exists = file_exists(DATA_FILE);

-    if (datafile_exists)
-        last_bootstrap_time = get_unix_time();
-
    if (!datafile_exists && !arg_opts.unencrypt_data)
        first_time_encrypt("Creating new data file. Would you like to encrypt it? Y/n (q to quit)");
    else if (arg_opts.encrypt_data)
@ -1247,21 +1164,26 @@ int main(int argc, char **argv)

    const char *p = arg_opts.config_path[0] ? arg_opts.config_path : NULL;

-    if (settings_load(user_settings, p) == -1)
-         queue_init_message("Failed to load user settings");
+    if (settings_load(user_settings, p) == -1) {
+        queue_init_message("Failed to load user settings");
+    }

-    int nameserver_ret = name_lookup_init();
+    int curl_init = curl_global_init(CURL_GLOBAL_ALL);
+    int nameserver_ret = name_lookup_init(curl_init);

-    if (nameserver_ret == -1)
+    if (nameserver_ret == -1) {
        queue_init_message("curl failed to initialize; name lookup service is disabled.");
-    else if (nameserver_ret == -2)
+    } else if (nameserver_ret == -2) {
        queue_init_message("Name lookup server list could not be found.");
-    else if (nameserver_ret == -3)
+    } else if (nameserver_ret == -3) {
        queue_init_message("Name lookup server list does not contain any valid entries.");
+    }

 #ifdef X11
+
    if (init_xtra(DnD_callback) == -1)
        queue_init_message("X failed to initialize");
+
 #endif

    Tox *m = load_toxic(DATA_FILE);
@ -1286,7 +1208,6 @@ int main(int argc, char **argv)
    if (pthread_create(&cqueue_thread.tid, NULL, thread_cqueue, (void *) m) != 0)
        exit_toxic_err("failed in main", FATALERR_THREAD_CREATE);

-
 #ifdef AUDIO

    av = init_audio(prompt, m);
@ -1304,17 +1225,31 @@ int main(int argc, char **argv)
    set_primary_device(output, user_settings->audio_out_dev);

 #elif SOUND_NOTIFY
+
    if ( init_devices() == de_InternalError )
        queue_init_message("Failed to init audio devices");

 #endif /* AUDIO */

+#ifdef PYTHON
+
+    init_python(m);
+    invoke_autoruns(prompt->chatwin->history, prompt);
+
+#endif /* PYTHON */
+
    init_notify(60, 3000);

    /* screen/tmux auto-away timer */
    if (init_mplex_away_timer(m) == -1)
        queue_init_message("Failed to init mplex auto-away.");

+    int nodeslist_ret = load_DHT_nodeslist();
+
+    if (nodeslist_ret != 0) {
+        queue_init_message("DHT nodeslist failed to load (error %d)", nodeslist_ret);
+    }
+
    pthread_mutex_lock(&Winthread.lock);
    print_init_messages(prompt);
    pthread_mutex_unlock(&Winthread.lock);
@ -1322,31 +1257,29 @@ int main(int argc, char **argv)
    cleanup_init_messages();

    /* set user avatar from config file. if no path is supplied tox_unset_avatar is called */
-    char avatarstr[MAX_STR_SIZE];
+    char avatarstr[PATH_MAX + 11];
    snprintf(avatarstr, sizeof(avatarstr), "/avatar \"%s\"", user_settings->avatar_path);
    execute(prompt->chatwin->history, prompt, m, avatarstr, GLOBAL_COMMAND_MODE);

-    uint64_t last_save = (uint64_t) time(NULL);
-    uint64_t looptimer = last_save;
-    useconds_t msleepval = 40000;
-    uint64_t loopcount = 0;
+    time_t last_save = get_unix_time();

    while (true) {
-        do_toxic(m, prompt);
+        do_toxic(m);

-        uint64_t cur_time = get_unix_time();
+        time_t cur_time = get_unix_time();

        if (timed_out(last_save, AUTOSAVE_FREQ)) {
            pthread_mutex_lock(&Winthread.lock);
+
            if (store_data(m, DATA_FILE) != 0)
                line_info_add(prompt, NULL, NULL, NULL, SYS_MSG, 0, RED, "WARNING: Failed to save to data file");
+
            pthread_mutex_unlock(&Winthread.lock);

            last_save = cur_time;
        }

-        msleepval = optimal_msleepval(&looptimer, &loopcount, cur_time, msleepval);
-        usleep(msleepval);
+        usleep(tox_iteration_interval(m) * 1000);
    }

    return 0;
--- a/src/toxic.h
+++ b/src/toxic.h
@ -70,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 "*"
@ -106,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);
--- a/src/toxic_strings.c
+++ b/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;
+}
--- a/src/toxic_strings.h
+++ b/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 */
--- a/src/video_call.c
+++ b/src/video_call.c
@ -40,13 +40,13 @@
 #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 );
+                             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);
+                               uint32_t video_bit_rate, void *user_data);

 static void print_err (ToxWindow *self, const char *error_str)
 {
@ -82,22 +82,24 @@ ToxAV *init_video(ToxWindow *self, Tox *tox)
 void terminate_video()
 {
    int i;
+
    for (i = 0; i < MAX_CALLS; ++i) {
-        Call* this_call = &CallControl.calls[i];
+        Call *this_call = &CallControl.calls[i];

        stop_video_transmission(this_call, i);

-        if( this_call->vout_idx != -1 )
+        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)
+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];
+    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 */
@ -117,9 +119,9 @@ void read_video_device_callback(int16_t width, int16_t height, const uint8_t* y,
 }

 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)
+                                 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);
 }
@ -175,16 +177,16 @@ int stop_video_transmission(Call *call, int friend_number)
 * 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)
+                            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)
+                              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);
@ -192,7 +194,7 @@ void video_bit_rate_status_cb(ToxAV *av, uint32_t friend_number, uint32_t audio_

 void callback_recv_video_starting(uint32_t friend_number)
 {
-    Call* this_call = &CallControl.calls[friend_number];
+    Call *this_call = &CallControl.calls[friend_number];

    if ( this_call->vout_idx != -1 )
        return;
@ -201,21 +203,22 @@ void callback_recv_video_starting(uint32_t friend_number)
 }
 void callback_recv_video_end(uint32_t friend_number)
 {
-    Call* this_call = &CallControl.calls[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];
+    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) ) {
@ -244,7 +247,7 @@ void callback_video_end(uint32_t friend_number)
 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];
+    Call *this_call = &CallControl.calls[self->num];

    if ( argc != 0 ) {
        error_str = "Unknown arguments.";
@ -387,18 +390,18 @@ void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, ch
    }

    if ( video_selection_valid(type, selection) == vde_InvalidSelection ) {
-        error_str="Invalid selection!";
+        error_str = "Invalid selection!";
        goto on_error;
    }

    /* If call is active, change device */
    if ( self->is_call ) {
-        Call* this_call = &CallControl.calls[self->num];
+        Call *this_call = &CallControl.calls[self->num];
+
        if ( this_call->ttas ) {

            if ( type == vdt_output ) {
-            }
-            else {
+            } else {
                /* TODO: check for failure */
                close_video_device(vdt_input, this_call->vin_idx);
                open_video_device(vdt_input, selection, &this_call->vin_idx);
@ -410,7 +413,7 @@ void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, ch
    self->video_device_selection[type] = selection;

    return;
-    on_error:
+on_error:
    print_err (self, error_str);
 }

--- a/src/video_device.c
+++ b/src/video_device.c
@ -30,14 +30,18 @@

 #include <vpx/vpx_image.h>

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__OSX__)
+#import "osx_video.h"
+#else
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <fcntl.h>
+#if defined(__linux__)
 #include <linux/videodev2.h>
-#else /* __OSX__ */
-#import "osx_video.h"
+#else
+#include <sys/videoio.h>
+#endif
 #endif

 #include "line_info.h"
@ -62,10 +66,10 @@ struct VideoBuffer {

 typedef struct VideoDevice {
    VideoDataHandleCallback cb;             /* Use this to handle data from input device usually */
-    void* cb_data;                          /* Data to be passed to callback */
+    void *cb_data;                          /* Data to be passed to callback */
    int32_t friend_number;                  /* ToxAV friend number */

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || SYSTEM == BSD
    int fd;                                 /* File descriptor of video device selected/opened */
    struct v4l2_format fmt;
    struct VideoBuffer *buffers;
@ -93,7 +97,7 @@ VideoDevice *video_devices_running[2][MAX_DEVICES] = {{NULL}};     /* Running de
 uint32_t primary_video_device[2];          /* Primary device */

 #ifdef VIDEO
-static ToxAV* av = NULL;
+static ToxAV *av = NULL;
 #endif /* VIDEO */

 /* q_mutex */
@ -102,15 +106,16 @@ static ToxAV* av = NULL;
 pthread_mutex_t video_mutex;

 bool video_thread_running = true,
-      video_thread_paused = true;                /* Thread control */
+     video_thread_paused = true;                /* Thread control */

-void* video_thread_poll(void*);
+void *video_thread_poll(void *);

 static void yuv420tobgr(uint16_t width, uint16_t height, const uint8_t *y,
-                 const uint8_t *u, const uint8_t *v, unsigned int ystride,
-                 unsigned int ustride, unsigned int vstride, uint8_t *out)
+                        const uint8_t *u, const uint8_t *v, unsigned int ystride,
+                        unsigned int ustride, unsigned int vstride, uint8_t *out)
 {
    unsigned long int i, j;
+
    for (i = 0; i < height; ++i) {
        for (j = 0; j < width; ++j) {
            uint8_t *point = out + 4 * ((i * width) + j);
@ -123,21 +128,23 @@ static void yuv420tobgr(uint16_t width, uint16_t height, const uint8_t *y,
            int g = (298 * (t_y - 16) - 100 * (t_u - 128) - 208 * (t_v - 128) + 128) >> 8;
            int b = (298 * (t_y - 16) + 516 * (t_u - 128) + 128) >> 8;

-            point[2] = r>255? 255 : r<0 ? 0 : r;
-            point[1] = g>255? 255 : g<0 ? 0 : g;
-            point[0] = b>255? 255 : b<0 ? 0 : b;
+            point[2] = r > 255 ? 255 : r < 0 ? 0 : r;
+            point[1] = g > 255 ? 255 : g < 0 ? 0 : g;
+            point[0] = b > 255 ? 255 : b < 0 ? 0 : b;
            point[3] = ~0;
        }
    }
 }

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || SYSTEM == BSD
 static void yuv422to420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v,
-                 uint8_t *input, uint16_t width, uint16_t height)
+                        uint8_t *input, uint16_t width, uint16_t height)
 {
    uint8_t *end = input + width * height * 2;
+
    while (input != end) {
        uint8_t *line_end = input + width * 2;
+
        while (input != line_end) {
            *plane_y++ = *input++;
            *plane_u++ = *input++;
@ -146,6 +153,7 @@ static void yuv422to420(uint8_t *plane_y, uint8_t *plane_u, uint8_t *plane_v,
        }

        line_end = input + width * 2;
+
        while (input != line_end) {
            *plane_y++ = *input++;
            input++;//u
@ -166,56 +174,59 @@ static int xioctl(int fh, unsigned long request, void *arg)
    return r;
 }

-#endif /* __linux__ */
+#endif

 /* Meet devices */
 #ifdef VIDEO
-VideoDeviceError init_video_devices(ToxAV* av_)
+VideoDeviceError init_video_devices(ToxAV *av_)
 #else
 VideoDeviceError init_video_devices()
 #endif /* VIDEO */
 {
    size[vdt_input] = 0;

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__OSX__)
+    if( osx_video_init((char**)video_devices_names[vdt_input], &size[vdt_input]) != 0 )
+        return vde_InternalError;
+#else /* not __OSX__*/
+
    for (; size[vdt_input] <= MAX_DEVICES; ++size[vdt_input]) {
        int fd;
        char device_address[] = "/dev/videoXX";
        snprintf(device_address + 10, sizeof(char) * strlen(device_address) - 10, "%i", size[vdt_input]);

        fd = open(device_address, O_RDWR | O_NONBLOCK, 0);
+
        if ( fd == -1 ) {
            break;
        } else {
            struct v4l2_capability cap;
-            char* video_input_name;
+            char *video_input_name;

            /* Query V4L for capture capabilities */
            if ( -1 != ioctl(fd, VIDIOC_QUERYCAP, &cap) ) {
-                video_input_name = (char*)malloc(strlen((const char*)cap.card) + strlen(device_address) + 4);
-                strcpy(video_input_name, (char*)cap.card);
+                video_input_name = (char *)malloc(strlen((const char *)cap.card) + strlen(device_address) + 4);
+                strcpy(video_input_name, (char *)cap.card);
                strcat(video_input_name, " (");
-                strcat(video_input_name, (char*)device_address);
+                strcat(video_input_name, (char *)device_address);
                strcat(video_input_name, ")");
            } else {
-                video_input_name = (char*)malloc(strlen(device_address) + 3);
+                video_input_name = (char *)malloc(strlen(device_address) + 3);
                strcpy(video_input_name, "(");
                strcat(video_input_name, device_address);
                strcat(video_input_name, ")");
            }
+
            video_devices_names[vdt_input][size[vdt_input]] = video_input_name;

            close(fd);
        }
    }

-#else /* __OSX__ */
-    if( osx_video_init((char**)video_devices_names[vdt_input], &size[vdt_input]) != 0 )
-        return vde_InternalError;
 #endif

    size[vdt_output] = 1;
-    char* video_output_name = "Toxic Video Receiver";
+    char *video_output_name = "Toxic Video Receiver";
    video_devices_names[vdt_output][0] = video_output_name;

    // Start poll thread
@ -223,6 +234,7 @@ VideoDeviceError init_video_devices()
        return vde_InternalError;

    pthread_t thread_id;
+
    if ( pthread_create(&thread_id, NULL, video_thread_poll, NULL) != 0 || pthread_detach(thread_id) != 0 )
        return vde_InternalError;

@ -236,12 +248,16 @@ VideoDeviceError init_video_devices()
 VideoDeviceError terminate_video_devices()
 {
    /* Cleanup if needed */
+    lock;
    video_thread_running = false;
+    unlock;
+
    usleep(20000);

    int i;
+
    for (i = 0; i < size[vdt_input]; ++i) {
-        free((void*)video_devices_names[vdt_input][i]);
+        free((void *)video_devices_names[vdt_input][i]);
    }

    if ( pthread_mutex_destroy(&video_mutex) != 0 )
@ -255,14 +271,19 @@ VideoDeviceError terminate_video_devices()
 }

 VideoDeviceError register_video_device_callback(int32_t friend_number, uint32_t device_idx,
-                                                VideoDataHandleCallback callback, void* data)
+        VideoDataHandleCallback callback, void *data)
 {
-#if defined(__linux__) || defined(__FreeBSD__)
-    if ( size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx] || !video_devices_running[vdt_input][device_idx]->fd )
-        return vde_InvalidSelection;
-#else /* __OSX__ */
+#if defined(__OSX__)
+
    if ( size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx] )
        return vde_InvalidSelection;
+
+#else /* not __OSX__ */
+
+    if ( size[vdt_input] <= device_idx || !video_devices_running[vdt_input][device_idx]
+            || !video_devices_running[vdt_input][device_idx]->fd )
+        return vde_InvalidSelection;
+
 #endif

    lock;
@ -283,7 +304,7 @@ VideoDeviceError set_primary_video_device(VideoDeviceType type, int32_t selectio
    return vde_None;
 }

-VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t* device_idx)
+VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t *device_idx)
 {
    return open_video_device(type, primary_video_device[type], device_idx);
 }
@ -293,7 +314,7 @@ void get_primary_video_device_name(VideoDeviceType type, char *buf, int size)
    memcpy(buf, dvideo_device_names[type], size);
 }

-VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t* device_idx)
+VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx)
 {
    if ( size[type] <= selection || selection < 0 ) return vde_InvalidSelection;

@ -324,7 +345,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
        }
    }

-    VideoDevice* device = video_devices_running[type][temp_idx] = calloc(1, sizeof(VideoDevice));
+    VideoDevice *device = video_devices_running[type][temp_idx] = calloc(1, sizeof(VideoDevice));
    device->selection = selection;

    if ( pthread_mutex_init(device->mutex, NULL) != 0 ) {
@ -336,12 +357,19 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
    if ( type == vdt_input ) {
        video_thread_paused = true;

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__OSX__)
+        if ( osx_video_open_device(selection, &device->video_width, &device->video_height) != 0 ) {
+            free(device);
+            unlock;
+            return vde_FailedStart;
+        }
+#else /* not __OSX__*/
        /* Open selected device */
        char device_address[] = "/dev/videoXX";
-        snprintf(device_address + 10 , sizeof(device_address) - 10, "%i", selection);
+        snprintf(device_address + 10, sizeof(device_address) - 10, "%i", selection);

        device->fd = open(device_address, O_RDWR);
+
        if ( device->fd == -1 ) {
            unlock;
            return vde_FailedStart;
@ -349,6 +377,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint

        /* Obtain video device capabilities */
        struct v4l2_capability cap;
+
        if ( -1 == xioctl(device->fd, VIDIOC_QUERYCAP, &cap) ) {
            close(device->fd);
            free(device);
@ -362,7 +391,8 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint

        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
-        if( -1 == xioctl(device->fd, VIDIOC_G_FMT, &fmt) ) {
+
+        if ( -1 == xioctl(device->fd, VIDIOC_S_FMT, &fmt) ) {
            close(device->fd);
            free(device);
            unlock;
@ -378,6 +408,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
        req.count = 4;
        req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        req.memory = V4L2_MEMORY_MMAP;
+
        if ( -1 == xioctl(device->fd, VIDIOC_REQBUFS, &req) ) {
            close(device->fd);
            free(device);
@ -411,20 +442,22 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint

            device->buffers[i].length = buf.length;
            device->buffers[i].start = mmap(NULL /* start anywhere */,
-                          buf.length,
-                          PROT_READ | PROT_WRITE /* required */,
-                          MAP_SHARED /* recommended */,
-                          device->fd, buf.m.offset);
+                                            buf.length,
+                                            PROT_READ | PROT_WRITE /* required */,
+                                            MAP_SHARED /* recommended */,
+                                            device->fd, buf.m.offset);

            if ( MAP_FAILED == device->buffers[i].start ) {
                for (i = 0; i < buf.index; ++i)
                    munmap(device->buffers[i].start, device->buffers[i].length);
+
                close(device->fd);
                free(device);
                unlock;
                return vde_FailedStart;
            }
        }
+
        device->n_buffers = i;

        enum v4l2_buf_type type;
@ -440,6 +473,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
            if ( -1 == xioctl(device->fd, VIDIOC_QBUF, &buf) ) {
                for (i = 0; i < device->n_buffers; ++i)
                    munmap(device->buffers[i].start, device->buffers[i].length);
+
                close(device->fd);
                free(device);
                unlock;
@ -456,12 +490,6 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
            return vde_FailedStart;
        }

-#else /* __OSX__ */
-        if ( osx_video_open_device(selection, &device->video_width, &device->video_height) != 0 ) {
-            free(device);
-            unlock;
-            return vde_FailedStart;
-        }
 #endif

        /* Create X11 window associated to device */
@ -474,15 +502,15 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
        int screen = DefaultScreen(device->x_display);

        if ( !(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
-                    device->video_width, device->video_height, 0, BlackPixel(device->x_display, screen),
-                    BlackPixel(device->x_display, screen))) ) {
+                                  device->video_width, device->video_height, 0, BlackPixel(device->x_display, screen),
+                                  BlackPixel(device->x_display, screen))) ) {
            close_video_device(vdt_input, temp_idx);
            unlock;
            return vde_FailedStart;
        }

        XStoreName(device->x_display, device->x_window, "Video Preview");
-        XSelectInput(device->x_display, device->x_window, ExposureMask|ButtonPressMask|KeyPressMask);
+        XSelectInput(device->x_display, device->x_window, ExposureMask | ButtonPressMask | KeyPressMask);

        if ( (device->x_gc = DefaultGC(device->x_display, screen)) == NULL ) {
            close_video_device(vdt_input, temp_idx);
@ -514,14 +542,14 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
        int screen = DefaultScreen(device->x_display);

        if ( !(device->x_window = XCreateSimpleWindow(device->x_display, RootWindow(device->x_display, screen), 0, 0,
-                    100, 100, 0, BlackPixel(device->x_display, screen), BlackPixel(device->x_display, screen))) ) {
+                                  100, 100, 0, BlackPixel(device->x_display, screen), BlackPixel(device->x_display, screen))) ) {
            close_video_device(vdt_output, temp_idx);
            unlock;
            return vde_FailedStart;
        }

        XStoreName(device->x_display, device->x_window, "Video Receive");
-        XSelectInput(device->x_display, device->x_window, ExposureMask|ButtonPressMask|KeyPressMask);
+        XSelectInput(device->x_display, device->x_window, ExposureMask | ButtonPressMask | KeyPressMask);

        if ( (device->x_gc = DefaultGC(device->x_display, screen)) == NULL ) {
            close_video_device(vdt_output, temp_idx);
@ -548,15 +576,15 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 }

 __inline VideoDeviceError write_video_out(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)
+        uint8_t const *y, uint8_t const *u, uint8_t const *v,
+        int32_t ystride, int32_t ustride, int32_t vstride,
+        void *user_data)
 {
-    VideoDevice* device = video_devices_running[vdt_output][0];
+    VideoDevice *device = video_devices_running[vdt_output][0];

    if ( !device ) return vde_DeviceNotActive;

-    if( !device->x_window ) return vde_DeviceNotActive;
+    if ( !device->x_window ) return vde_DeviceNotActive;

    pthread_mutex_lock(device->mutex);

@ -591,7 +619,7 @@ __inline VideoDeviceError write_video_out(uint16_t width, uint16_t height,
        .red_mask = 0xFF0000,
        .green_mask = 0xFF00,
        .blue_mask = 0xFF,
-        .data = (char*)img_data
+        .data = (char *)img_data
    };

    /* Render image data */
@ -606,7 +634,7 @@ __inline VideoDeviceError write_video_out(uint16_t width, uint16_t height,
    return vde_None;
 }

-void* video_thread_poll (void* arg) // TODO: maybe use thread for every input source
+void *video_thread_poll (void *arg) // TODO: maybe use thread for every input source
 {
    /*
     * NOTE: We only need to poll input devices for data.
@ -614,25 +642,36 @@ void* video_thread_poll (void* arg) // TODO: maybe use thread for every input so
    (void)arg;
    uint32_t i;

-    while (video_thread_running)
-    {
+    while (1) {
+        lock;
+
+        if (!video_thread_running) {
+            unlock;
+            break;
+        }
+
+        unlock;
+
        if ( video_thread_paused ) usleep(10000); /* Wait for unpause. */
-        else
-        {
-            for (i = 0; i < size[vdt_input]; ++i)
-             {
+        else {
+            for (i = 0; i < size[vdt_input]; ++i) {
                lock;
-                if ( video_devices_running[vdt_input][i] != NULL )
-                {
+
+                if ( video_devices_running[vdt_input][i] != NULL ) {
                    /* Obtain frame image data from device buffers */
-                    VideoDevice* device = video_devices_running[vdt_input][i];
+                    VideoDevice *device = video_devices_running[vdt_input][i];
                    uint16_t video_width = device->video_width;
                    uint16_t video_height = device->video_height;
                    uint8_t *y = device->input.planes[0];
                    uint8_t *u = device->input.planes[1];
                    uint8_t *v = device->input.planes[2];

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__OSX__)
+                    if ( osx_video_read_device(y, u, v, &video_width, &video_height) != 0 ) {
+                        unlock;
+                        continue;
+                    }
+#else /* not __OSX__*/
                    struct v4l2_buffer buf;
                    memset(&(buf), 0, sizeof(buf));

@ -644,16 +683,11 @@ void* video_thread_poll (void* arg) // TODO: maybe use thread for every input so
                        continue;
                    }

-                    void *data = (void*)device->buffers[buf.index].start;
+                    void *data = (void *)device->buffers[buf.index].start;

                    /* Convert frame image data to YUV420 for ToxAV */
                    yuv422to420(y, u, v, data, video_width, video_height);

-#else /* __OSX__*/
-                    if ( osx_video_read_device(y, u, v, &video_width, &video_height) != 0 ) {
-                        unlock;
-                        continue;
-                    }
 #endif

                    /* Send frame data to friend through ToxAV */
@ -663,7 +697,7 @@ void* video_thread_poll (void* arg) // TODO: maybe use thread for every input so
                    /* Convert YUV420 data to BGR */
                    uint8_t *img_data = malloc(video_width * video_height * 4);
                    yuv420tobgr(video_width, video_height, y, u, v,
-                                video_width, video_width/2, video_width/2, img_data);
+                                video_width, video_width / 2, video_width / 2, img_data);

                    /* Allocate image data in X11 */
                    XImage image = {
@ -679,7 +713,7 @@ void* video_thread_poll (void* arg) // TODO: maybe use thread for every input so
                        .red_mask = 0xFF0000,
                        .green_mask = 0xFF00,
                        .blue_mask = 0xFF,
-                        .data = (char*)img_data
+                        .data = (char *)img_data
                    };

                    /* Render image data */
@ -690,16 +724,20 @@ void* video_thread_poll (void* arg) // TODO: maybe use thread for every input so
                    XFlush(device->x_display);
                    free(img_data);

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || SYSTEM == BSD
+
                    if ( -1 == xioctl(device->fd, VIDIOC_QBUF, &buf) ) {
                        unlock;
                        continue;
                    }
-#endif /* __linux__ */
+
+#endif /* __linux__ / BSD */

                }
+
                unlock;
            }
+
            usleep(1000 * 1000 / 24);
        }
    }
@ -725,19 +763,23 @@ VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx)
    if ( !device->ref_count ) {

        if ( type == vdt_input ) {
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__OSX__)
+
+            osx_video_close_device(device_idx);
+#else /* not __OSX__ */
            enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-            if( -1 == xioctl(device->fd, VIDIOC_STREAMOFF, &buf_type) ) {}
+
+            if ( -1 == xioctl(device->fd, VIDIOC_STREAMOFF, &buf_type) ) {}

            int i;
+
            for (i = 0; i < device->n_buffers; ++i) {
                if ( -1 == munmap(device->buffers[i].start, device->buffers[i].length) ) {
                }
            }
+
            close(device->fd);

-#else /* __OSX__ */
-            osx_video_close_device(device_idx);
 #endif
            vpx_img_free(&device->input);
            XDestroyWindow(device->x_display, device->x_window);
@ -745,9 +787,9 @@ VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx)
            XCloseDisplay(device->x_display);
            pthread_mutex_destroy(device->mutex);

-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || SYSTEM == BSD
            free(device->buffers);
-#endif /* __linux__ */
+#endif /* __linux__ / BSD */

            free(device);
        } else {
@ -759,14 +801,13 @@ VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx)
            free(device);
        }

-    }
-    else device->ref_count--;
+    } else device->ref_count--;

    unlock;
    return rc;
 }

-void print_video_devices(ToxWindow* self, VideoDeviceType type)
+void print_video_devices(ToxWindow *self, VideoDeviceType type)
 {
    int i;

--- a/src/video_device.h
+++ b/src/video_device.h
@ -45,10 +45,11 @@ typedef enum VideoDeviceError {
    vde_CaptureError = -9,
 } VideoDeviceError;

-typedef void (*VideoDataHandleCallback) (int16_t width, int16_t height, const uint8_t* y, const uint8_t* u, const uint8_t* v, void* data);
+typedef void (*VideoDataHandleCallback) (int16_t width, int16_t height, const uint8_t *y, const uint8_t *u,
+        const uint8_t *v, void *data);

 #ifdef VIDEO
-VideoDeviceError init_video_devices(ToxAV* av);
+VideoDeviceError init_video_devices(ToxAV *av);
 #else
 VideoDeviceError init_video_devices();
 #endif /* VIDEO */
@ -56,20 +57,22 @@ VideoDeviceError init_video_devices();
 VideoDeviceError terminate_video_devices();

 /* Callback handles ready data from INPUT device */
-VideoDeviceError register_video_device_callback(int32_t call_idx, uint32_t device_idx, VideoDataHandleCallback callback, void* data);
-void* get_video_device_callback_data(uint32_t device_idx);
+VideoDeviceError register_video_device_callback(int32_t call_idx, uint32_t device_idx, VideoDataHandleCallback callback,
+        void *data);
+void *get_video_device_callback_data(uint32_t device_idx);

 VideoDeviceError set_primary_video_device(VideoDeviceType type, int32_t selection);
-VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t* device_idx);
+VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t *device_idx);
 /* Start device */
-VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t* device_idx);
+VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx);
 /* Stop device */
 VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx);

 /* Write data to device */
-VideoDeviceError write_video_out(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);
+VideoDeviceError write_video_out(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 print_video_devices(ToxWindow* self, VideoDeviceType type);
+void print_video_devices(ToxWindow *self, VideoDeviceType type);
 void get_primary_video_device_name(VideoDeviceType type, char *buf, int size);

 VideoDeviceError video_selection_valid(VideoDeviceType type, int32_t selection);
--- a/src/windows.c
+++ b/src/windows.c
@ -151,8 +151,8 @@ void on_friendadded(Tox *m, uint32_t friendnumber, bool sort)
    store_data(m, DATA_FILE);
 }

-void on_groupmessage(Tox *m, int groupnumber, int peernumber, const uint8_t *message, uint16_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)
 {
    char msg[MAX_STR_SIZE + 1];
    length = copy_tox_str(msg, sizeof(msg), (const char *) message, length);
@ -161,26 +161,12 @@ void on_groupmessage(Tox *m, int groupnumber, int peernumber, const uint8_t *mes

    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
        if (windows[i].onGroupMessage != NULL)
-            windows[i].onGroupMessage(&windows[i], m, groupnumber, peernumber, msg, length);
+            windows[i].onGroupMessage(&windows[i], m, groupnumber, peernumber, type, msg, length);
    }
 }

-void on_groupaction(Tox *m, int groupnumber, int peernumber, const uint8_t *action, uint16_t length,
-                    void *userdata)
-{
-    char msg[MAX_STR_SIZE + 1];
-    length = copy_tox_str(msg, sizeof(msg), (const char *) action, length);
-
-    size_t i;
-
-    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i].onGroupAction != NULL)
-            windows[i].onGroupAction(&windows[i], m, groupnumber, peernumber, msg, length);
-    }
-}
-
-void on_groupinvite(Tox *m, int32_t friendnumber, uint8_t type, const uint8_t *group_pub_key, uint16_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)
 {
    size_t i;

@ -190,7 +176,8 @@ void on_groupinvite(Tox *m, int32_t friendnumber, uint8_t type, const uint8_t *g
    }
 }

-void on_group_namelistchange(Tox *m, int groupnumber, int peernumber, uint8_t change, void *userdata)
+void on_group_namelistchange(Tox *m, uint32_t groupnumber, uint32_t peernumber, TOX_CONFERENCE_STATE_CHANGE change,
+                             void *userdata)
 {
    size_t i;

@ -200,7 +187,7 @@ void on_group_namelistchange(Tox *m, int groupnumber, int peernumber, uint8_t ch
    }
 }

-void on_group_titlechange(Tox *m, int groupnumber, int peernumber, const uint8_t *title, uint8_t length,
+void on_group_titlechange(Tox *m, uint32_t groupnumber, uint32_t peernumber, const uint8_t *title, size_t length,
                          void *userdata)
 {
    char data[MAX_STR_SIZE + 1];
@ -445,10 +432,12 @@ void on_window_resize(void)
        }

 #ifdef AUDIO
+
        if (w->chatwin->infobox.active) {
            delwin(w->chatwin->infobox.win);
            w->chatwin->infobox.win = newwin(INFOBOX_HEIGHT, INFOBOX_WIDTH + 1, 1, x2 - INFOBOX_WIDTH);
        }
+
 #endif   /* AUDIO */

        scrollok(w->chatwin->history, 0);
@ -458,29 +447,34 @@ void on_window_resize(void)
 static void draw_window_tab(ToxWindow *toxwin)
 {
    pthread_mutex_lock(&Winthread.lock);
+
    if (toxwin->alert != WINDOW_ALERT_NONE) attron(COLOR_PAIR(toxwin->alert));
+
    pthread_mutex_unlock(&Winthread.lock);

    clrtoeol();
    printw(" [%s]", toxwin->name);

    pthread_mutex_lock(&Winthread.lock);
+
    if (toxwin->alert != WINDOW_ALERT_NONE) attroff(COLOR_PAIR(toxwin->alert));
+
    pthread_mutex_unlock(&Winthread.lock);
 }

 static void draw_bar(void)
 {
+    int y, x;
+
+    // save current cursor position
+    getyx(active_window->window, y, x);
+
    attron(COLOR_PAIR(BLUE));
    mvhline(LINES - 2, 0, '_', COLS);
    attroff(COLOR_PAIR(BLUE));

    move(LINES - 1, 0);

-    attron(COLOR_PAIR(BLUE) | A_BOLD);
-    printw(" TOXIC " TOXICVER " |");
-    attroff(COLOR_PAIR(BLUE) | A_BOLD);
-
    size_t i;

    for (i = 0; i < MAX_WINDOWS_NUM; ++i) {
@ -508,6 +502,9 @@ static void draw_bar(void)
            attroff(A_BOLD);
    }

+    // restore cursor position after drawing
+    move(y, x);
+
    refresh();
 }

@ -525,6 +522,7 @@ void draw_active_window(Tox *m)

    touchwin(a->window);
    a->onDraw(a, m);
+    wrefresh(a->window);

    /* Handle input */
    bool ltr;
@ -586,6 +584,12 @@ ToxWindow *get_window_ptr(int i)
    return toxwin;
 }

+/* returns a pointer to the currently open ToxWindow. */
+ToxWindow *get_active_window(void)
+{
+    return active_window;
+}
+
 void force_refresh(WINDOW *w)
 {
    wclear(w);
--- a/src/windows.h
+++ b/src/windows.h
@ -121,11 +121,10 @@ struct ToxWindow {
    void(*onNickChange)(ToxWindow *, Tox *, uint32_t, const char *, size_t);
    void(*onStatusChange)(ToxWindow *, Tox *, uint32_t, TOX_USER_STATUS);
    void(*onStatusMessageChange)(ToxWindow *, uint32_t, const char *, size_t);
-    void(*onGroupMessage)(ToxWindow *, Tox *, int, int, const char *, uint16_t);
-    void(*onGroupAction)(ToxWindow *, Tox *, int, int, const char *, uint16_t);
+    void(*onGroupMessage)(ToxWindow *, Tox *, uint32_t, uint32_t, TOX_MESSAGE_TYPE, const char *, size_t);
    void(*onGroupInvite)(ToxWindow *, Tox *, int32_t, uint8_t, const char *, uint16_t);
-    void(*onGroupNamelistChange)(ToxWindow *, Tox *, int, int, uint8_t);
-    void(*onGroupTitleChange)(ToxWindow *, Tox *, int, int, const char *, uint8_t);
+    void(*onGroupNamelistChange)(ToxWindow *, Tox *, uint32_t, uint32_t, TOX_CONFERENCE_STATE_CHANGE);
+    void(*onGroupTitleChange)(ToxWindow *, Tox *, uint32_t, uint32_t, const char *, size_t);
    void(*onFileChunkRequest)(ToxWindow *, Tox *, uint32_t, uint32_t, uint64_t, size_t);
    void(*onFileRecvChunk)(ToxWindow *, Tox *, uint32_t, uint32_t, uint64_t, const char *, size_t);
    void(*onFileControl)(ToxWindow *, Tox *, uint32_t, uint32_t, TOX_FILE_CONTROL);
@ -153,7 +152,7 @@ struct ToxWindow {
 #ifdef VIDEO

    int video_device_selection[2]; /* -1 if not set, if set uses these selections instead of primary video device */
-    
+
 #endif /* VIDEO */

 #endif /* AUDIO */
@ -204,8 +203,8 @@ struct infobox {
    bool hide;
    bool active;

-    uint64_t lastupdate;
-    uint64_t starttime;
+    time_t lastupdate;
+    time_t starttime;
    char timestr[TIME_STR_SIZE];

    WINDOW *win;
@ -237,6 +236,7 @@ struct ChatContext {
 #endif

    uint8_t self_is_typing;
+    uint8_t pastemode; /* whether to translate \r to \n */

    WINDOW *history;
    WINDOW *linewin;
@ -259,6 +259,7 @@ void kill_all_windows(Tox *m);    /* should only be called on shutdown */
 void on_window_resize(void);
 void force_refresh(WINDOW *w);
 ToxWindow *get_window_ptr(int i);
+ToxWindow *get_active_window(void);

 /* refresh inactive windows to prevent scrolling bugs.
   call at least once per second */
--- a/src/xtra.c
+++ b/src/xtra.c
@ -57,8 +57,7 @@ struct _Xtra {
    Atom expecting_type;
 } Xtra;

-typedef struct _Property
-{
+typedef struct _Property {
    unsigned char *data;
    int            read_format;
    unsigned long  read_num;
@ -97,21 +96,23 @@ Property read_property(Window s, Atom p)
 Atom get_dnd_type(long *a, int l)
 {
    int i = 0;
+
    for (; i < l; i ++) {
        if (a[i] != XtraNil) return a[i]; /* Get first valid */
    }
+
    return XtraNil;
 }

 /* TODO maybe support only certain types in the future */
-static void handle_xdnd_enter(XClientMessageEvent* e)
+static void handle_xdnd_enter(XClientMessageEvent *e)
 {
    Xtra.handling_version = (e->data.l[1] >> 24);

    if ((e->data.l[1] & 1)) {
        // Fetch the list of possible conversions
        Property p = read_property(e->data.l[0], XdndTypeList);
-        Xtra.expecting_type = get_dnd_type((long*)p.data, p.read_num);
+        Xtra.expecting_type = get_dnd_type((long *)p.data, p.read_num);
        XFree(p.data);
    } else {
        // Use the available list
@ -119,7 +120,7 @@ static void handle_xdnd_enter(XClientMessageEvent* e)
    }
 }

-static void handle_xdnd_position(XClientMessageEvent* e)
+static void handle_xdnd_position(XClientMessageEvent *e)
 {
    XEvent ev = {
        .xclient = {
@ -143,7 +144,7 @@ static void handle_xdnd_position(XClientMessageEvent* e)
    XFlush(Xtra.display);
 }

-static void handle_xdnd_drop(XClientMessageEvent* e)
+static void handle_xdnd_drop(XClientMessageEvent *e)
 {
    /* Not expecting any type */
    if (Xtra.expecting_type == XtraNil) {
@ -172,7 +173,7 @@ static void handle_xdnd_drop(XClientMessageEvent* e)
    }
 }

-static void handle_xdnd_selection(XSelectionEvent* e)
+static void handle_xdnd_selection(XSelectionEvent *e)
 {
    /* DnD succesfully finished, send finished and call callback */
    XEvent ev = {
@ -199,12 +200,12 @@ static void handle_xdnd_selection(XSelectionEvent* e)


    /* Call callback for every entry */
-    if (Xtra.on_drop && p.read_num)
-    {
+    if (Xtra.on_drop && p.read_num) {
        char *sptr;
        char *str = strtok_r((char *) p.data, "\n\r", &sptr);

        if (str) Xtra.on_drop(str, dt);
+
        while ((str = strtok_r(NULL, "\n\r", &sptr)))
            Xtra.on_drop(str, dt);
    }
@ -212,7 +213,7 @@ static void handle_xdnd_selection(XSelectionEvent* e)
    if (p.data) XFree(p.data);
 }

-void *event_loop(void* p)
+void *event_loop(void *p)
 {
    /* Handle events like a real nigga */

@ -221,30 +222,27 @@ void *event_loop(void* p)
    XEvent event;
    int pending;

-    while (Xtra.display)
-    {
+    while (Xtra.display) {
        /* NEEDMOEVENTSFODEMPROGRAMS */

        XLockDisplay(Xtra.display);
-        if((pending = XPending(Xtra.display))) XNextEvent(Xtra.display, &event);

-        if (!pending)
-        {
+        if ((pending = XPending(Xtra.display))) XNextEvent(Xtra.display, &event);
+
+        if (!pending) {
            XUnlockDisplay(Xtra.display);
            usleep(10000);
            continue;
        }

-        if (event.type == ClientMessage)
-        {
+        if (event.type == ClientMessage) {
            Atom type = event.xclient.message_type;

            if      (type == XdndEnter)         handle_xdnd_enter(&event.xclient);
            else if (type == XdndPosition)      handle_xdnd_position(&event.xclient);
            else if (type == XdndDrop)          handle_xdnd_drop(&event.xclient);
            else if (type == XtraTerminate)     break;
-        }
-        else if (event.type == SelectionNotify) handle_xdnd_selection(&event.xselection);
+        } else if (event.type == SelectionNotify) handle_xdnd_selection(&event.xselection);
        /* AINNOBODYCANHANDLEDEMEVENTS*/
        else XSendEvent(Xtra.display, Xtra.terminal_window, 0, 0, &event);

@ -256,6 +254,7 @@ void *event_loop(void* p)
     * otherwise HEWUSAGUDBOI happens
     */
    if (Xtra.display) XCloseDisplay(Xtra.display);
+
    return (Xtra.display = NULL);
 }

@ -267,10 +266,16 @@ int init_xtra(drop_callback d)
    else Xtra.on_drop = d;

    XInitThreads();
+
    if ( !(Xtra.display = XOpenDisplay(NULL))) return -1;

    Xtra.terminal_window = focused_window_id();

+    /* OSX: if focused window is 0, it means toxic is ran from
+     * native terminal and not X11 terminal window, silently exit */
+    if (!Xtra.terminal_window)
+        return 0;
+
    {
        /* Create an invisible window which will act as proxy for the DnD operation. */
        XSetWindowAttributes attr  = {0};
@ -295,15 +300,15 @@ int init_xtra(drop_callback d)
                     &root, &x, &y, &wht, &hht, &b, &d);

        if (! (Xtra.proxy_window = XCreateWindow
-                        (Xtra.display, Xtra.terminal_window,       /* Parent */
-                         0, 0,                                     /* Position */
-                         wht, hht,                                 /* Width + height */
-                         0,                                        /* Border width */
-                         CopyFromParent,                           /* Depth */
-                         InputOnly,                                /* Class */
-                         CopyFromParent,                           /* Visual */
-                         CWEventMask | CWCursor,                   /* Value mask */
-                         &attr)) )                                 /* Attributes for value mask */
+                                   (Xtra.display, Xtra.terminal_window,       /* Parent */
+                                    0, 0,                                     /* Position */
+                                    wht, hht,                                 /* Width + height */
+                                    0,                                        /* Border width */
+                                    CopyFromParent,                           /* Depth */
+                                    InputOnly,                                /* Class */
+                                    CopyFromParent,                           /* Visual */
+                                    CWEventMask | CWCursor,                   /* Value mask */
+                                    &attr)) )                                 /* Attributes for value mask */
            return -1;
    }

@ -330,9 +335,10 @@ int init_xtra(drop_callback d)
                    XA_ATOM,
                    32,
                    PropModeReplace,
-                    (unsigned char*)&XdndVersion, 1);
+                    (unsigned char *)&XdndVersion, 1);

    pthread_t id;
+
    if (pthread_create(&id, NULL, event_loop, NULL) != 0)
        return -1;

@ -343,7 +349,7 @@ int init_xtra(drop_callback d)

 void terminate_xtra()
 {
-    if (!Xtra.display) return;
+    if (!Xtra.display || !Xtra.terminal_window) return;

    XEvent terminate = {
        .xclient = {
--- a/src/xtra.h
+++ b/src/xtra.h
@ -28,10 +28,10 @@
 typedef enum {
    DT_plain,
    DT_file_list
-} 
+}
 DropType;

-typedef void (*drop_callback) (const char*, DropType);
+typedef void (*drop_callback) (const char *, DropType);

 int               init_xtra(drop_callback d);
 void              terminate_xtra();
Author	SHA1	Message	Date
jfreegman	b1d8ab102f	Bump to version 0.8.1	2017-11-17 17:44:56 -05:00
jfreegman	c387df35f8	Merge branch 'f8l-pkgsrc'	2017-11-16 16:03:20 -05:00
Mateusz Poszwa	351a50c214	Do not assume what is not Linux or a BSD descendant is OSX	2017-11-15 21:02:10 +01:00
jfreegman	93175314b5	Merge branch 'aSourceFish-master'	2017-11-15 02:25:55 -05:00
aSourceFish	b905a1a3c5	One more bit of standard...	2017-11-15 05:56:13 +02:00
aSourceFish	c4386b195f	A bit of standard...	2017-11-15 05:54:46 +02:00
aSourceFish	ed1e617380	Make Toxic compile at NetBSD, STAGE 2	2017-11-15 05:50:00 +02:00
aSourceFish	1382adb1f6	Make Toxic compile at NetBSD, STAGE 1	2017-11-15 05:46:47 +02:00
aSourceFish	ecf1c317b7	Make Toxic compile at NetBSD, STAGE 0	2017-11-15 05:24:19 +02:00
jfreegman	cf0b99f1e5	Merge branch 'aramchandran-master'	2017-11-13 15:37:40 -05:00
Abhishek Ramchandran	3605a296a9	Update install.mk	2017-11-13 13:30:22 -05:00
jfreegman	9375d220f9	Merge branch 'aSourceFish-master'	2017-11-11 16:51:34 -05:00
aSourceFish	8f94b0a218	Shut down the warning at *BSD	2017-11-11 21:17:34 +02:00
aSourceFish	85a0becbf9	Make Toxic compile at OpenBSD	2017-11-11 21:04:45 +02:00
aSourceFish	fec36ad9e6	Make Toxic compile at OpenBSD	2017-11-11 21:03:28 +02:00
jfreegman	ecdf6f01d2	Merge branch 'EnniRosario-refresh_devices'	2017-10-31 16:24:53 -04:00
Enni Rosario	e1bfa30769	Refresh device list on /lsdev.	2017-10-31 18:08:06 +02:00
Enni Rosario	ebcbc7497b	Indicate selected device when printing.	2017-10-31 17:45:39 +02:00
jfreegman	e844ece28b	Merge branch 'zugz-reduceRedrawing'	2017-10-29 16:00:46 -04:00
zugz	8508451ba6	avoid unnecessary redrawing	2017-10-29 16:50:42 +01:00
jfreegman	5cc83a7cb5	Merge branch 'patheticpat-fix-tmux'	2017-09-05 17:43:13 -04:00
Michael Kaiser	febc725763	Fix tmux detached detection 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.	2017-09-05 12:49:48 +02:00
jfreegman	f2c116feb3	Fix potential string truncations with snprintf	2017-09-01 17:36:17 -04:00
jfreegman	52dd60dc86	Fix potential int truncation and double-check lengths before copy	2017-08-28 19:37:19 -04:00
jfreegman	80c0500299	Fix formatting bug caused by strings containing \r	2017-08-28 18:26:52 -04:00
jfreegman	ab490d28b4	Merge branch 'avoidr-status_cmd_feedback'	2017-08-28 17:13:53 -04:00
avoidr	a9f7f85617	/status: give feedback to user on status change	2017-08-27 12:27:04 +02:00
jfreegman	1bfc1ba371	Merge branch 'Dako300-master'	2017-07-07 20:03:07 -04:00
Daniel Hoffman	2ede39369a	added /bitrate	2017-07-07 23:47:59 +00:00
jfreegman	922c184195	Only include python libs when necessary	2017-06-06 19:03:40 -04:00
jfreegman	56a9571509	Make sure message id fits inside a signed int	2017-06-02 01:15:44 -04:00
jfreegman	0136f22076	Fix UI bugs & format This fixes a bug where lines would sometimes be incorrectly marked as unread, as well as a bug where inbound messages would sometimes be coloured incorrectly	2017-06-01 16:46:12 -04:00
jfreegman	c4ace288af	Bump to v0.8.0	2017-05-24 15:10:50 -04:00
jfreegman	6d3fbfee59	Merge branch 'TsarFox-master'	2017-05-24 14:57:32 -04:00
=	be5e7906da	Fix fortune.py input issues	2017-05-24 10:10:18 -04:00
jakob	369f26932e	Fix error messages being printed when autorun_path is unset.	2017-05-23 19:12:53 -04:00
jakob	22ea522baf	Add "/run" to autocompleter and fix example Python script.	2017-05-22 20:47:56 -04:00
jakob	4f60d546e6	Disable Python support in the default build	2017-05-21 16:18:39 -04:00
jakob	76d1eafdc0	Change visibility on Python commands list	2017-05-20 08:18:28 -04:00
jakob	37912f2d88	Update INSTALL.md	2017-05-19 21:09:29 -04:00
jfreegman	09710327c5	Merge branch 'Dako300-master'	2017-05-19 20:05:52 -04:00
Daniel Hoffman	acee4615f8	double signal handler prevents accidental closes	2017-05-19 14:38:39 -05:00
jakob	5ed26eda9b	Added constants to the Python interface for calls to execute.	2017-05-19 15:35:31 -04:00
jakob	6d2b90ac9f	Error reporting on failure of invoke_autoruns and solved issue with call to Py_FinalizeEx	2017-05-18 21:37:28 -04:00
jakob	02ea0fac44	get_status returns a string rather than an integer.	2017-05-17 08:39:29 -04:00
jakob	7d3d129624	Updated code style	2017-05-16 23:19:39 -04:00
jakob	b3ed8bc35c	Finalized and documented the Python scripting interface.	2017-05-16 20:31:23 -04:00
jakob	90210daca7	Python interface for getting the user's nickname/status and executing commands	2017-05-15 22:12:28 -04:00
jakob	0e13a1f1bc	Implemented a basic Python scripting engine, optional compilation.	2017-05-15 20:29:00 -04:00
nurupo	09e2690211	Fixed INSTALL formatting (#443 )	2017-04-12 12:00:43 -04:00
jfreegman	e65e3af274	Merge branch 'peetcamron-fix/fflush-for-musl'	2017-01-28 00:45:28 -05:00
root	c6c60d018e	Added some fflush after the printf with no \n so we don't have a blank screen when compiled with musl.	2017-01-28 00:06:03 -05:00
jfreegman	451d4ced80	Add option that prints toxic and toxcore version	2017-01-25 22:13:59 -05:00
jfreegman	7a7402ff86	Update text files with new toktok toxcore link	2016-12-21 17:08:32 -05:00
jfreegman	600e013adc	Bump to version 0.7.2	2016-12-18 00:11:24 -05:00
jfreegman	1d71e2eb18	Port to toktok-c-toxcore branch	2016-12-18 00:01:51 -05:00
Jfreegman	f858714edd	Fix small nodeslist parsing bug	2016-10-23 12:26:18 -04:00
Jfreegman	4df44a7274	Merge branch 'tharvik-master'	2016-10-18 12:21:58 -04:00
tharvik	a26ed9d28f	add missing implicit include	2016-10-18 09:38:28 +02:00
louisabraham	2bd5083b8f	Corrected brew errors (#413 ) Corrected brew errors	2016-10-07 13:24:31 -04:00
Jfreegman	8805f694b9	Merge branch 'Ansa89-qr_png'	2016-10-06 11:48:33 -04:00
Ansa89	71040355fd	QR: close file descriptor on error	2016-10-06 11:54:27 +02:00
Ansa89	6bc5d8c543	QR PNG: convert some variables to macros	2016-10-06 11:52:26 +02:00
Jfreegman	abb39ea6b5	Fix a few resource leaks	2016-10-05 15:17:56 -04:00
Jfreegman	15846d2b50	Merge branch 'Ansa89-qr'	2016-10-05 14:58:10 -04:00
Ansa89	958df9f2e8	Add possibility to save QR code in PNG file format	2016-10-05 20:57:50 +02:00
Jfreegman	2fd43aebee	Merge branch 'Ansa89-fix_checks'	2016-10-05 12:23:23 -04:00
Ansa89	34c29745cc	Makefile: use correct variable name when checking video libs	2016-10-05 09:09:22 +02:00
Ansa89	da6fe41d75	Makefile: fix video libs check	2016-10-04 10:25:49 +02:00
Thierry Thomas	e17fa89d8f	Update misc_tools.c (#408 ) * Update misc_tools.c Fix build on FreeBSD with clang. Without this patch, compilation fails with these messages: CC misc_tools.o /usr/ports/net-im/toxic/work/toxic-0.7.1/src/misc_tools.c:479:24: error: variable has incomplete type 'struct sockaddr_in' struct sockaddr_in s_addr; ^ /usr/ports/net-im/toxic/work/toxic-0.7.1/src/misc_tools.c:479:12: note: forward declaration of 'struct sockaddr_in' struct sockaddr_in s_addr; ^ /usr/ports/net-im/toxic/work/toxic-0.7.1/src/misc_tools.c:480:22: error: use of undeclared identifier 'AF_INET' return inet_pton(AF_INET, address, &(s_addr.sin_addr)) != 0; ^ 2 errors generated. * Fix build on FreeBSD with clang Without this patch, compilation fails with these messages: CC misc_tools.o /usr/ports/net-im/toxic/work/toxic-0.7.1/src/misc_tools.c:479:24: error: variable has incomplete type 'struct sockaddr_in' struct sockaddr_in s_addr; ^ /usr/ports/net-im/toxic/work/toxic-0.7.1/src/misc_tools.c:479:12: note: forward declaration of 'struct sockaddr_in' struct sockaddr_in s_addr; ^ /usr/ports/net-im/toxic/work/toxic-0.7.1/src/misc_tools.c:480:22: error: use of undeclared identifier 'AF_INET' return inet_pton(AF_INET, address, &(s_addr.sin_addr)) != 0; ^ 2 errors generated.	2016-09-25 22:32:17 -04:00
Jfreegman	f056f13329	Astyle everything and add an astyle options script to repo	2016-09-24 21:07:04 -04:00
Jfreegman	3515623159	Bump version to 0.7.1	2016-09-23 13:05:05 -04:00
Jfreegman	2194b9e259	Use time_t instead of uint64_t for timestamps Also call time() directly from get_unix_time() instead of manually updating the time val.	2016-09-22 18:31:52 -04:00
Jfreegman	c24e1bd2b8	Fix a few A/V race conditions	2016-09-22 18:00:14 -04:00
Jfreegman	38ec96e96a	Thread nodeslist loading This is necessary because DNS/http lookups block, and can do so for a very long time	2016-09-22 14:09:07 -04:00
Jfreegman	d2b572ede1	Add ipv6 support for bootstrap nodes and refactor parsing code	2016-09-21 21:22:05 -04:00
Jfreegman	703d5419a3	Ignore offline bootstrap nodes, small refactor of Nodes struct	2016-09-21 12:51:57 -04:00
Jfreegman	221d761ff4	Ignore bootstrap nodes that use a domain instead of IP address Domains cause toxcore to do blocking DNS requests which creates noticable lag and might (??) leak IP addresses when using a proxy	2016-09-21 00:28:16 -04:00
Jfreegman	151f5f0c51	Add setting to control DHT nodeslist update frequency Also rename a few things and semi-fix man page format issues	2016-09-20 13:13:12 -04:00
Jfreegman	4f6c603543	Rename DHTnodes to DHTnodes.json	2016-09-20 00:53:53 -04:00
Jfreegman	a009f11c0c	Automatically update DHT nodeslist List is now automatically fetched from nodes.tox.chat and placed in the user config directory. The list is updated once every 30 days, and will attempt to detect problems and re-fetch the list if necessary. Also fixed a couple file descriptor leaks and cleaned some things up.	2016-09-20 00:00:09 -04:00
Jfreegman	1f8c11a33a	These strlen() calls are unncessary	2016-09-18 11:34:13 -04:00
Jfreegman	5e20e6b279	Switch to using json DHT nodes file Parsing json manually like this is ugly, but this allows us to use the json formatted nodeslist file at nodes.tox.chat instead of having to update the list by hand. We could also potentially use curl to fetch the list and update it automatically.	2016-09-17 21:38:32 -04:00
Jfreegman	1f02bb2be5	Refactor DHT bootstrap code - Separate node list loading from connecting - Put code in its own source file - Rename a few functions	2016-09-17 14:26:23 -04:00
Jfreegman	98154b3cba	Merge branch 'kdhp-master'	2016-09-15 11:27:04 -04:00
Keegan Drake H.P	379ad9e116	Use ALC_ENUMERATE_ALL_EXT when available	2016-09-14 05:43:10 -05:00
JFreegman	cb21672600	Merge pull request #403 from metala/fix-set-video-fmt Changed video get format to set format	2016-07-28 12:30:28 -04:00
Marin Ivanov	4019395f44	Changed video get format to set format * Fixes issue #394 * This was obviously meant to set the video format.	2016-07-28 17:58:24 +02:00
JFreegman	ee084c572c	Merge pull request #402 from metala/fix-chat-infobox-flicker Remove chat infobox flicker	2016-07-27 22:38:23 -04:00
Marin Ivanov	41a8401ac5	Merge branch 'master' into fix-chat-infobox-flicker Fixed cursor position issue	2016-07-27 22:04:41 +02:00
JFreegman	d8a3f7de4c	Merge pull request #401 from metala/fix-remote-help-flicker Remove help window flicker	2016-07-27 12:16:12 -04:00
Marin Ivanov	c425aa2f27	Fixed input lag	2016-07-27 18:06:33 +02:00
Marin Ivanov	94e026d114	Remove chat infobox flicker	2016-07-27 02:39:31 +02:00
Marin Ivanov	f89638635a	Remove help window flicker	2016-07-27 02:07:31 +02:00
Jfreegman	402b86687f	Merge branch 'mphe-beep'	2016-07-21 11:35:22 -04:00
Marvin Ewald	5b1b420ac0	Add further explanation to the beep_on* options This also renames beep_on* to bell_on*.	2016-07-21 11:35:09 +02:00
JFreegman	62ec514f17	Merge pull request #400 from Encrypt/master Added a changelog to the project	2016-07-19 14:04:05 -04:00
Yann Privé	f893dd755f	Added a changelog to the project	2016-07-19 00:06:52 +01:00
Marvin Ewald	9aedcf7753	Update docs	2016-07-17 19:22:40 +02:00
Marvin Ewald	d3effa26b5	Add options to enable terminal bell on certain events Some terminals can mark the terminal window as urgent on bell. This is useful for window managers that provide a shortcut to jump to an urgent client.	2016-07-17 19:22:40 +02:00
Jfreegman	2ec180789b	Fix crash on AV error call state during active call	2016-07-11 17:42:57 -04:00
Jfreegman	9f74d3a3a8	Fix memory leak	2016-06-29 21:36:54 -04:00
Jfreegman	9fcbc3bde0	Fix tab-complete bug causing buffer to sometimes clear	2016-06-11 23:49:56 -04:00
Jfreegman	cf16849b37	Dynamically allocate memory for save file instead of using stack	2016-05-03 14:13:16 -04:00
Jfreegman	32442b6286	Disallow ctrl+m keybinding and revert to default settings on invalid bindings Note: Ctrl+m uses the same control sequence as the enter key on many systems	2016-05-01 14:57:46 -04:00
Jfreegman	50f227418b	Update man pages	2016-04-25 22:04:43 -04:00
Jfreegman	fc06a625a6	Put toxme.io back as it has a new owner	2016-04-25 14:49:23 -04:00
Jfreegman	70bd39eb74	Fix small bug	2016-04-11 18:50:28 -04:00
Jfreegman	4e0e322e32	Fix cross-client audio issue	2016-04-05 00:49:46 -04:00
Jfreegman	e73ac9b6a4	Remove defunct nameserver	2016-03-30 00:30:47 -04:00
Jfreegman	bcda6e476e	Fix bug for real this time	2016-03-12 02:29:59 -05:00
Jfreegman	5b29ce7132	Fix bug preventing friend connection status from changing	2016-03-03 20:49:48 -05:00
Jfreegman	f43f644451	Merge branch 'mall0c-multiline'	2016-02-29 19:22:41 -05:00
Marvin Ewald	d6fdac9739	Fix markup in multiline messages A '<' or '>' at the beginning of a line will now highlight only this particular line instead of the whole message.	2016-02-29 01:46:48 +01:00
Marvin Ewald	c6a2bb8a90	Add settings option to set paste-mode key and update docs	2016-02-28 21:53:33 +01:00
Marvin Ewald	04576fea7e	Add paste-mode to allow multiline text pasting Ctrl-T toggles paste mode. Useful when pasting multiline text because it avoids triggering an enter keypress after linebreaks. Instead, every \r is translated to \n which is again translated to a pilcrow (see previous commit). The pasted text can then be sent as a whole instead of splitting up in multiple messages.	2016-02-28 21:40:41 +01:00
Marvin Ewald	e6f839f9ac	Enable multiline input Adds a nonl() call to avoid translation from \r to \n when pressing enter. C-J -> \n Enter -> \r To allow multiline input, \n chars (e.g. when pressing C-J) are replaced with a pilcrow. After hitting enter, every pilcrow is substituted with \n again.	2016-02-28 02:35:36 +01:00
Jfreegman	eb02424f8a	Update DHT nodes list	2016-02-25 19:04:37 -05:00
Jfreegman	2e609c46f6	Remove file transfer timeoutes, and remove a couple unused functions	2016-02-25 17:58:02 -05:00
Jfreegman	a474e3bf39	Add settings option to disable friend connection change notifications	2016-02-25 17:06:49 -05:00
JFreegman	93835f0455	Merge pull request #379 from FreakyPenguin/password_eval Add password_eval option to skip password prompt	2016-01-19 18:31:04 -05:00
Antoine Kaufmann	ac6d8ff89c	Add password_eval option to skip password prompt Runs a command and uses its output as the password. This can be used for getting the password from a password manager such as pass.	2016-01-19 13:45:52 -08:00
JFreegman	88e74224ed	Merge pull request #374 from quininer/master sleep use tox_iteration_interval	2016-01-11 04:09:56 -05:00
quininer	deccaec40e	fix milliseconds	2015-12-22 10:43:08 +08:00
quininer	4419be36e8	remove useless var	2015-12-21 20:00:48 +08:00
quininer	b34b51e8c1	use tox_iteration_interval	2015-12-21 18:13:03 +08:00
JFreegman	74416b4b58	Merge pull request #373 from wedge-jarrad/master Fix #372 - can't start with missing ~/.config	2015-12-18 01:11:16 -05:00
Wedge Jarrad	675712cea0	Fix #372 - can't start with missing ~/.config This block was added in `fa0e645`. I'm unsure what bug or corner case it was intended to address but it causes Toxic to exit with an error if the ~/.config directory doesn't exist. Without this block the ~/.config directory and tox-specific subdirectories will be created when Toxic starts.	2015-12-17 18:17:34 -08:00
Jfreegman	36feebfe8d	Merge branch 'RomeroMalaquias-master'	2015-12-09 01:32:07 -05:00
Romero Malaquias	3fe9abd84d	Avoiding conditional directives that split up parts os statements	2015-12-08 23:13:39 -03:00
Romero Malaquias	fd6432c727	Avoiding conditional directives that split up parts os statements	2015-12-08 23:10:16 -03:00
JFreegman	1feffcc2f0	Merge pull request #369 from nil0x42/master update doc: DATA_FILE is now `toxic_profile.tox`	2015-12-07 16:11:07 -05:00
nil0x42	6bba3cb9e2	update doc: DATA_FILE is now `toxic_profile.tox`	2015-12-07 13:38:07 +01:00
Jfreegman	3cb6db3d60	Remove pointless null check	2015-12-05 00:19:11 -05:00
Jfreegman	77238eeadf	Improve file transfer progress bar	2015-12-04 19:41:50 -05:00
JFreegman	88270827a9	Merge pull request #367 from landswellsong/osx-terminal-xtra-fix Correctly operational from OSX terminals	2015-11-25 03:42:55 -05:00
Oleksiy Protas	aade65bfe1	Correctly operational from OSX terminals	2015-11-25 10:26:12 +02:00
Jfreegman	b24c5d8cf8	Fix AV bug Pending call now properly hangs up when you use the /hangup command or close the chat window	2015-11-19 23:49:58 -05:00
Jfreegman	9f0feb7223	Allow custom nospam values	2015-11-12 18:03:45 -05:00
				`@ -1,2 +1 @@`
				`toxme.io 1A39E7A5D5FA9CF155C751570A32E625698A60A55F6D88028F949F66144F4F25`