13 files changed, 568 insertions, 74 deletions

diff --git a/README.md b/README.md
index e5e93532..81836b4f 100644
--- a/README.md
+++ b/README.md
@@ -49,9 +49,9 @@ configure for the normal user or suffer from being way too centralized.
 
 - [Installation](/INSTALL.md)
 - [Commands](/docs/commands.rst)
-- [DHT Protocol](https://github.com/irungentoo/ProjectTox-Core/wiki/DHT)<br />
-- [Lossless UDP Protocol](https://github.com/irungentoo/ProjectTox-Core/wiki/Lossless-UDP)<br />
-- [Crypto](https://github.com/irungentoo/ProjectTox-Core/wiki/Crypto)<br />
-- [Ideas](https://github.com/irungentoo/ProjectTox-Core/wiki/Ideas)
+- [DHT Protocol](http://wiki.tox.im/index.php/DHT)<br />
+- [Lossless UDP Protocol](http://wiki.tox.im/index.php/Lossless_UDP)<br />
+- [Crypto](http://wiki.tox.im/index.php/Crypto)<br />
+- [Ideas](http://wiki.tox.im/index.php/Ideas)
 
 [String]: https://en.wikipedia.org/wiki/String_(computer_science)
diff --git a/auto_tests/messenger_test.c b/auto_tests/messenger_test.c
index 64b44d5f..28747899 100644
--- a/auto_tests/messenger_test.c
+++ b/auto_tests/messenger_test.c
@@ -169,7 +169,7 @@ START_TEST(test_getself_name)
     char nick_check[len];
 
     setname(m, (uint8_t *)nickname, len);
-    getself_name(m, (uint8_t *)nick_check);
+    getself_name(m, (uint8_t *)nick_check, len);
 
     ck_assert_msg((!STRINGS_EQUAL(nickname, nick_check)),
         "getself_name failed to return the known name!\n"
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 55a41912..ad6eea01 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -10,7 +10,8 @@ set(core_sources
         LAN_discovery.c
         Messenger.c
         util.c
-        ping.c)
+        ping.c
+    timer.c)
 
 if(SHARED_TOXCORE)
         add_library(toxcore SHARED ${core_sources})
diff --git a/core/Messenger.c b/core/Messenger.c
index ebde5a78..af102406 100644
--- a/core/Messenger.c
+++ b/core/Messenger.c
@@ -22,6 +22,8 @@
  */
 
 #include "Messenger.h"
+#include "timer.h"
+
 #define MIN(a,b) (((a)<(b))?(a):(b))
 
 static void set_friend_status(Messenger *m, int friendnumber, uint8_t status);
@@ -267,10 +269,18 @@ int setname(Messenger *m, uint8_t * name, uint16_t length)
    put it in name
    name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH bytes.
    return the length of the name */
-uint16_t getself_name(Messenger *m, uint8_t *name)
+uint16_t getself_name(Messenger *m, uint8_t *name, uint16_t nlen)
 {
+    uint16_t len;
+
+    if (name == NULL || nlen == 0) {
+        return 0;
+    }
+
+    len = MIN(nlen, m->name_length);
     memcpy(name, m->name, m->name_length);
-    return m->name_length;
+
+    return len;
 }
 
 /* get name of friendnumber
@@ -480,7 +490,20 @@ int write_cryptpacket_id(Messenger *m, int friendnumber, uint8_t packet_id, uint
     return write_cryptpacket(m->friendlist[friendnumber].crypt_connection_id, packet, length + 1);
 }
 
+
+/*Interval in seconds between LAN discovery packet sending*/
+#define LAN_DISCOVERY_INTERVAL 60
+
 #define PORT 33445
+
+/*Send a LAN discovery packet every LAN_DISCOVERY_INTERVAL seconds*/
+int LANdiscovery(timer* t, void* arg)
+{
+    send_LANdiscovery(htons(PORT));
+    timer_start(t, LAN_DISCOVERY_INTERVAL);
+    return 0;
+}
+
 /* run this at startup */
 Messenger * initMessenger(void)
 {
@@ -502,6 +525,8 @@ Messenger * initMessenger(void)
     friendreq_init();
     LANdiscovery_init();
 
+    timer_single(&LANdiscovery, 0, LAN_DISCOVERY_INTERVAL);
+
     return m;
 }
 
@@ -660,20 +685,6 @@ void doInbound(Messenger *m)
     }
 }
 
-/*Interval in seconds between LAN discovery packet sending*/
-#define LAN_DISCOVERY_INTERVAL 60
-
-static uint64_t last_LANdiscovery;
-
-/*Send a LAN discovery packet every LAN_DISCOVERY_INTERVAL seconds*/
-void LANdiscovery(Messenger *m)
-{
-    if (last_LANdiscovery + LAN_DISCOVERY_INTERVAL < unix_time()) {
-        send_LANdiscovery(htons(PORT));
-        last_LANdiscovery = unix_time();
-    }
-}
-
 
 /* the main loop that needs to be run at least 200 times per second. */
 void doMessenger(Messenger *m)
@@ -685,7 +696,8 @@ void doMessenger(Messenger *m)
     doNetCrypto();
     doInbound(m);
     doFriends(m);
-    LANdiscovery(m);
+    
+    timer_poll();
 }
 
 /* returns the size of the messenger data (for saving) */
diff --git a/core/Messenger.h b/core/Messenger.h
index fa69d104..aa9611a4 100644
--- a/core/Messenger.h
+++ b/core/Messenger.h
@@ -196,10 +196,18 @@ int m_sendaction(Messenger *m, int friendnumber, uint8_t *action, uint32_t lengt
    return -1 if failure */
 int setname(Messenger *m, uint8_t *name, uint16_t length);
 
-/* get our nickname
-   put it in name
-   return the length of the name*/
-uint16_t getself_name(Messenger *m, uint8_t *name);
+/**
+ * @brief Get your nickname.
+ *
+ * @param[in]  m        The messanger context to use.
+ *
+ * @param[inout]  name    Pointer to a string for the name.
+ *
+ * @param[in]  nlen     The length of the string buffer.
+ *
+ * @return Return the length of the name, 0 on error.
+ */
+uint16_t getself_name(Messenger *m, uint8_t *name, uint16_t nlen);
 
 /* get name of friendnumber
     put it in name
diff --git a/core/timer.c b/core/timer.c
new file mode 100644
index 00000000..06e25693
--- /dev/null
+++ b/core/timer.c
@@ -0,0 +1,275 @@
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+
+#include "timer.h"
+#include "network.h"
+
+/* 
+A nested linked list increases efficiency of insertions.
+Depending on the number of timers we have, we might need to have nested linked lists
+in order to improve insertion efficiency.
+The code below is preperation for that end, should it be necessary.
+
+typedef struct {
+    struct timer_package* _next;
+    union {
+        timer_packet* _inner;
+        timer* queue;
+    };
+    uint64_t pkgtime;
+} timer_package;
+
+timer_package* timer_package_pool;
+
+static timer_package* new_package()
+{
+    timer_package* ret;
+    if (timer_package_pool) {
+        ret = timer_package_pool;
+        timer_package_pool = timer_package_pool->_next;
+    } else {
+        ret = calloc(1, sizeof(struct timer_package));
+    }
+    return ret;
+}
+
+static void delete_package(timer_package* p)
+{
+    p->_next = timer_package_pool;
+    timer_package_pool = p;
+}
+*/
+
+enum timer_state {
+    STATE_INACTIVE = 0,
+    STATE_ACTIVE,
+    STATE_CALLBACK
+};
+
+struct timer
+{
+    enum timer_state state;
+    timer* _prev;
+    timer* _next;
+    timer_callback cb;
+    void* userdata;
+    uint64_t deadline;
+};
+
+static timer* timer_main_queue;
+static timer* timer_us_queue; /* hi-speed queue */
+
+inline static void timer_dequeue(timer* t, timer** queue)
+{
+    if (t->state == STATE_INACTIVE) return; /* not in a queue */
+    
+    if (t->_prev) {
+        t->_prev->_next = t->_next;
+    } else {
+        *queue = t->_next;
+    }
+    if (t->_next) t->_next->_prev = t->_prev;
+    t->state = STATE_INACTIVE;
+}
+
+static void timer_enqueue(timer* t, timer** queue, timer* prev)
+{
+    t->state = STATE_ACTIVE;
+    while (true) {
+        if (!*queue) {
+            t->_next = 0;
+            t->_prev = prev;
+            *queue = t;
+            return;
+        }
+
+        if ((*queue)->deadline > t->deadline) {
+            (*queue)->_prev = t;
+            t->_next = *queue;
+            t->_prev = prev;
+            *queue = t;
+            return;
+        }
+
+        prev = *queue;
+        queue = &((*queue)->_next);
+    }
+}
+
+/*** interface ***/
+
+void timer_init()
+{
+    /* Nothing needs to be done... yet. */
+}
+
+/* Do not depend on fields being zeroed */
+static timer* timer_pool; /* timer_pool is SINGLY LINKED!! */
+
+timer* new_timer(void)
+{
+    timer* ret;
+    if (timer_pool) {
+        ret = timer_pool;
+        timer_pool = timer_pool->_next;
+    } else {
+        ret = calloc(1, sizeof(struct timer));
+    }
+    ret->state = STATE_INACTIVE;
+    return ret;
+}
+
+void delete_timer(timer* t)
+{
+    timer_dequeue(t, &timer_main_queue);
+    t->_next = timer_pool;
+    t->state = STATE_INACTIVE;
+    timer_pool = t;
+}
+
+void timer_setup(timer* t, timer_callback cb, void* userarg)
+{
+    t->cb = cb;
+    t->userdata = userarg;
+}
+
+void* timer_get_userdata(timer* t)
+{
+    return t->userdata;
+}
+
+static void timer_delay_us(timer* t, int us)
+{
+    t->deadline += us;
+    timer** queue = t->_prev ? &(t->_prev->_next) : &timer_main_queue;
+    timer_dequeue(t, &timer_main_queue);
+    timer_enqueue(t, queue, t->_prev);
+}
+
+/* Starts the timer so that it's called in sec seconds in the future. 
+ * A non-positive value of sec results in the callback being called immediately.
+ * This function may be called again after a timer has been started to adjust 
+ * the expiry time. */
+void timer_start(timer* t, int sec)
+{
+    uint64_t newdeadline = current_time() + sec * US_PER_SECOND;
+    if (timer_is_active(t)){
+        if (t->deadline < newdeadline) {
+            timer_delay_us(t, newdeadline - t->deadline);
+            return;
+        }
+        timer_dequeue(t, &timer_main_queue);
+    }
+    t->deadline = newdeadline;
+    timer_enqueue(t, &timer_main_queue, 0);
+}
+
+/* Stops the timer. Returns -1 if the timer was not active. */
+int timer_stop(timer* t)
+{
+    int ret = timer_is_active(t) ? -1 : 0;
+    timer_dequeue(t, &timer_main_queue);
+    return ret;
+}
+
+/* Adds additionalsec seconds to the timer. 
+ * Returns -1 and does nothing if the timer was not active. */
+int timer_delay(timer* t, int additonalsec)
+{
+    if (!timer_is_active(t)) return -1;
+    timer_delay_us(t, additonalsec * US_PER_SECOND);
+    return 0;
+}
+
+static uint64_t timer_diff(timer* t, uint64_t time)
+{
+    if (t->deadline <= time) return 0;
+    return time - t->deadline;
+}
+
+/* Returns the time remaining on a timer in seconds.
+ * Returns -1 if the timer is not active.
+ * Returns 0 if the timer has expired and will be called upon the next call to timer_poll. */
+int timer_time_remaining(timer* t)
+{
+    if (!timer_is_active(t)) return -1;
+    return timer_diff(t, current_time()) / US_PER_SECOND;
+}
+
+bool timer_is_active(timer* t)
+{
+    return t->state != STATE_INACTIVE;
+}
+
+/* Single-use timer.
+ * Creates a new timer, preforms setup and starts it. */
+void timer_single(timer_callback cb, void* userarg, int sec)
+{
+    timer* t = new_timer();
+    timer_setup(t, cb, userarg);
+    timer_start(t, sec);
+}
+
+/* Single-use microsecond timer. */
+void timer_us(timer_callback cb, void* userarg, int us)
+{
+    timer* t = new_timer();
+    timer_setup(t, cb, userarg);
+    t->deadline = current_time() + us;
+    t->state = STATE_ACTIVE;
+    timer_enqueue(t, &timer_us_queue, 0);
+}
+
+uint64_t prevtime = 0;
+void timer_poll(void)
+{
+    uint64_t time = current_time();
+
+    /* Handle millisecond timers */
+    while (timer_us_queue) {
+        if (timer_diff(timer_us_queue, time) != 0) break;
+        timer* t = timer_us_queue;
+        timer_dequeue(t, &timer_us_queue);
+        t->cb(0, t->userdata);
+        delete_timer(t);
+    }
+
+    if (time - prevtime > US_PER_SECOND || prevtime == 0 || prevtime > time) { 
+        /* time moving backwards is just a sanity check */
+        prevtime = time;
+        
+        while (timer_main_queue) {
+            if (timer_diff(timer_main_queue, time) != 0) break;
+            timer* t = timer_main_queue;
+            t->state = STATE_CALLBACK;
+            int rv = t->cb(t, t->userdata);
+            if (rv != 0) {
+                timer_dequeue(t, &timer_main_queue);
+                delete_timer(t);
+                continue;
+            }
+            if (t->state != STATE_ACTIVE) {
+                timer_dequeue(t, &timer_main_queue);
+            }
+        }
+    }
+}
+
+/*** Internal Testing ***/
+
+/* I do not want to expose internals to the public, 
+ * which is why internals testing is done this way. */
+void timer_internal_tests(bool (*assert)(bool, char*))
+{
+    
+}
+
+void timer_debug_print()
+{
+    timer* t = timer_main_queue;
+    printf("Queue:\n");
+    while (t) {
+        printf("%" PRIu64 " (%" PRIu64 ") : %s\n", t->deadline, t->deadline/US_PER_SECOND, (char*)t->userdata);
+        t = t->_next;
+    }
+}
diff --git a/core/timer.h b/core/timer.h
new file mode 100644
index 00000000..8844a1dd
--- /dev/null
+++ b/core/timer.h
@@ -0,0 +1,104 @@
+/*  timer.h
+ *
+ *  Timing subsystem. Provides deadline timers.
+ *  All times are aliased to a second for efficiency.
+ *
+ *  Timer Guarantees:
+ *  - The callback will not be called before the timer expires.
+ *  - The callback will be called sometime after the timer expires,
+ *    on a best effort basis.
+ *  - If timer_poll is called at least once a second, the callback
+ *    will be called at most one second after it expires.
+ *
+ *  Copyright (C) 2013 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TIMER_H
+#define TIMER_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define US_PER_SECOND 1000000 /* 1 s = 10^6 us */
+
+struct timer;
+typedef struct timer timer;
+
+/* If time_callback returns a non-zero value, timer t is deleted.
+ * You may call any of the timer functions within the callback:
+ * For example, you may call timer_start to restart the timer from
+ * within a callback. */
+typedef int (*timer_callback)(timer* t, void* userarg);
+
+/* Initisalise timer subsystem */
+void timer_init(void);
+
+/* Poll. (I will eventually replace all polling in Tox with an async system.) */
+void timer_poll(void);
+
+/* Creates a new timer. Does not enqueue/start it. */
+timer* new_timer(void);
+
+/* Destroys a timer instance. */
+void delete_timer(timer* t);
+
+/* Sets up the timer callback. */
+void timer_setup(timer* t, timer_callback cb, void* userarg);
+
+/* Accessor Function. */
+void* timer_get_userdata(timer* t);
+
+/* Starts the timer so that it's called in sec seconds in the future from now. 
+ * A non-positive value of sec results in the callback being called immediately.
+ * This function may be called again after a timer has been started to adjust 
+ * the expiry time. */
+void timer_start(timer* t, int sec);
+
+/* Stops the timer. Returns -1 if the timer was not active. */
+int timer_stop(timer* t);
+
+/* Adds additionalsec seconds to the timer. 
+ * Returns -1 and does nothing if the timer was not active. */
+int timer_delay(timer* t, int additonalsec);
+
+/* Returns the time remaining on a timer in seconds.
+ * Returns -1 if the timer is not active.
+ * Returns 0 if the timer has expired and the callback hasn't been called yet. */
+int timer_time_remaining(timer* t);
+
+/* Determines if timer is active. Returns TRUE if it is active */
+bool timer_is_active(timer* t);
+
+/* Single-use timer.
+ * Creates a new timer, preforms setup and starts it. 
+ * Callback must return a non-zero value to prevent memory leak. */
+void timer_single(timer_callback cb, void* userarg, int sec);
+
+/* Single-use microsecond timer.
+ * Creates a new timer, preforms setup and starts it. 
+ * Please do not use this when accuracy is not absolutely required.
+ * Use when one needs to time a period < 1 s.
+ * Use the more coarse timers above for periods > 5 s. 
+ * WARNING: the callback will be called with NULL as the first argument */
+void timer_us(timer_callback cb, void* userarg, int us);
+
+/* Internal Testing */
+void timer_internal_tests(bool(*)(bool, char*));
+
+#endif
diff --git a/testing/CMakeLists.txt b/testing/CMakeLists.txt
index 7322509a..65ba35c0 100644
--- a/testing/CMakeLists.txt
+++ b/testing/CMakeLists.txt
@@ -9,6 +9,7 @@ include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Lossless_UDP_testclient.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Lossless_UDP_testserver.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Messenger_test.cmake)
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/crypto_speed_test.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/timer_test.cmake)
 
 if(WIN32)
         include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/nTox_win32.cmake)
diff --git a/testing/cmake/timer_test.cmake b/testing/cmake/timer_test.cmake
new file mode 100644
index 00000000..a5f8c5ec
--- /dev/null
+++ b/testing/cmake/timer_test.cmake
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 2.6.0)
+project(timer_test C)
+
+set(exe_name timer_test)
+
+add_executable(${exe_name}
+        timer_test.c)
+
+linkCoreLibraries(${exe_name})
diff --git a/testing/nTox.c b/testing/nTox.c
index 59d1cbf6..74db2ae2 100644
--- a/testing/nTox.c
+++ b/testing/nTox.c
@@ -113,7 +113,7 @@ char *format_message(Messenger *m, char *message, int friendnum)
     if (friendnum != -1) {
             getname(m, friendnum, (uint8_t*)name);
     } else {
-            getself_name(m, (uint8_t*)name);
+            getself_name(m, (uint8_t*)name, sizeof(name));
     }
     char *msg = malloc(100+strlen(message)+strlen(name)+1);
 
diff --git a/testing/timer_test.c b/testing/timer_test.c
new file mode 100644
index 00000000..63083940
--- /dev/null
+++ b/testing/timer_test.c
@@ -0,0 +1,66 @@
+#include "../core/timer.h"
+#include <stdio.h>
+
+#ifdef WINDOWS
+#include <windows.h>
+#else 
+#include <unistd.h>
+#endif
+
+void mssleep(int ms)
+{
+#ifdef WINDOWS
+    Sleep(ms);
+#else
+    usleep(ms * 1000);
+#endif
+}
+
+int callback(timer* t, void* arg){
+    printf("%s\n", (char*)arg);
+    return 1;
+}
+
+int repeating(timer* t, void *arg) {
+    printf("%s\n", (char*)arg);
+    timer_start(t, 3);
+    return 0;
+}
+
+extern void timer_debug_print();
+
+int main(int argc, char** argv)
+{
+    timer_init();
+    timer_debug_print();
+    
+    timer* t = new_timer();
+    timer_setup(t, &callback, "Long setup method, 4 seconds");
+    timer_start(t, 4);
+    timer_debug_print();
+
+    timer_single(&repeating, (void*)"This repeats every 3 seconds", 3);
+    timer_debug_print();
+
+    timer_single(&callback, "Short method, 4 seconds", 4);
+    timer_debug_print();
+
+    timer_single(&callback, "1 second", 1);
+    timer_debug_print();
+
+    timer_single(&callback, "15 seconds", 15);
+    timer_debug_print();
+
+    timer_single(&callback, "10 seconds", 10);
+    timer_debug_print();
+    
+    timer_us(&callback, "100000us", 100000);
+    timer_us(&callback, "13s", 13 * US_PER_SECOND);
+
+    while (true) {
+        timer_poll();
+        mssleep(10);
+    }
+
+    return 0;
+}
diff --git a/testing/toxic/chat.c b/testing/toxic/chat.c
index a0a4b576..32c05dec 100644
--- a/testing/toxic/chat.c
+++ b/testing/toxic/chat.c
@@ -236,7 +236,7 @@ void execute(ToxWindow *self, ChatContext *ctx, Messenger *m, char *cmd)
     wattroff(ctx->history, COLOR_PAIR(2));
 
     uint8_t selfname[MAX_NAME_LENGTH];
-    int len = getself_name(m, selfname);
+    int len = getself_name(m, selfname, sizeof(selfname));
     char msg[MAX_STR_SIZE-len-4];
     snprintf(msg, sizeof(msg), "* %s %s\n", (uint8_t*) selfname, action);
 
diff --git a/testing/toxic/configdir.c b/testing/toxic/configdir.c
index 6cbb06bc..18e211ce 100644
--- a/testing/toxic/configdir.c
+++ b/testing/toxic/configdir.c
@@ -28,65 +28,83 @@
 #ifdef WIN32
 #include <shlobj.h>
 #include <direct.h>
-#endif
-
-#ifdef __APPLE__
+#else /* WIN32 */
 #include <unistd.h>
 #include <pwd.h>
-#endif
+#endif /* WIN32 */
 
 #include "configdir.h"
 
-/*
- * Retrieves a correct configuration directory, depending on the OS used, with a trailing slash
+/**
+ * @brief Get the users config directory.
+ *
+ * This is without a trailing slash.
+ *
+ * @return The users config dir or NULL on error.
  */
 char *get_user_config_dir(void)
 {
-  char *user_config_dir;
+    char *user_config_dir;
+#ifdef WIN32
+    char appdata[MAX_PATH];
+    BOOL ok;
 
-  #ifdef WIN32
+    ok = SHGetSpecialFolderPathA(NULL, appdata, CSIDL_PROFILE, TRUE);
+    if (!ok) {
+        return NULL;
+    }
 
-  char appdata[MAX_PATH];
-  HRESULT result = SHGetFolderPath(
-    NULL,
-    CSIDL_APPDATA,
-    NULL,
-    SHGFP_TYPE_CURRENT,
-    appdata
-  )
-  if (!result) return NULL;
-
-  user_config_dir = strdup(appdata);
-
-  return user_config_dir;
-
-  #elif defined __APPLE__
-
-  struct passwd *pass = getpwuid(getuid());
-  if (!pass) return NULL;
-  char *home = pass->pw_dir;
-  user_config_dir = malloc(strlen(home) + strlen("/Library/Application Support") + 1);
-  
-  if(user_config_dir) {
-    strcpy(user_config_dir, home);
-    strcat(user_config_dir, "/Library/Application Support");
-  }
-  return user_config_dir;
+    user_config_dir = strdup(appdata);
+
+    return user_config_dir;
+
+#else /* WIN32 */
+
+#ifndef NSS_BUFLEN_PASSWD
+#define NSS_BUFLEN_PASSWD 4096
+#endif /* NSS_BUFLEN_PASSWD */
+
+    struct passwd pwd;
+    struct passwd *pwdbuf;
+    const char *home;
+    char buf[NSS_BUFLEN_PASSWD];
+    size_t len;
+    int rc;
+
+    rc = getpwuid_r(getuid(), &pwd, buf, NSS_BUFLEN_PASSWD, &pwdbuf);
+    if (rc == 0) {
+        home = pwd.pw_dir;
+    } else {
+        home = getenv("HOME");
+        if (home == NULL) {
+            return NULL;
+        }
+        /* env variables can be tainted */
+        snprintf(buf, sizeof(buf), "%s", home);
+        home = buf;
+    }
 
-  #else
+# if defined(__APPLE__)
+    len = strlen(home) + strlen("/Library/Application Support") + 1;
+    user_config_dir = malloc(len);
+    if (user_config_dir == NULL) {
+        return NULL;
+    }
 
-  if (getenv("XDG_CONFIG_HOME")) {
-    user_config_dir = strdup(getenv("XDG_CONFIG_HOME"));
-  } else {
-    user_config_dir = malloc(strlen(getenv("HOME")) + strlen("/.config") + 1);
-    if (user_config_dir) {
-      strcpy(user_config_dir, getenv("HOME"));
-      strcat(user_config_dir, "/.config");
+    snprintf(user_config_dir, len, "%s/Library/Application Support", home);
+# else /* __APPLE__ */
+    len = strlen(home) + strlen("/.config") + 1;
+    user_config_dir = malloc(len);
+    if (user_config_dir == NULL) {
+        return NULL;
     }
-  }
-  return user_config_dir;
 
-  #endif
+    snprintf(user_config_dir, len, "%s/.config", home);
+# endif /* __APPLE__ */
+
+    return user_config_dir;
+#undef NSS_BUFLEN_PASSWD
+#endif /* WIN32 */
 }
 
 /*