Added debug logging of free_nullsafe() calls as well

27 files changed, 149 insertions, 138 deletions

diff --git a/common/eurephia_nullsafe.c b/common/eurephia_nullsafe.c
index 92747e5..bcca178 100644
--- a/common/eurephia_nullsafe.c
+++ b/common/eurephia_nullsafe.c
@@ -68,3 +68,11 @@ void *__malloc_nullsafe(eurephiaCTX *ctx, size_t sz, const char *file, int line)
         }
         return buf;
 }
+
+void inline __free_nullsafe(eurephiaCTX *ctx, void *ptr, const char *file, int line) {
+        if( ptr == NULL ) {
+                return;
+        }
+        DEBUG(ctx, 40, "Freeing memory on address %p (File %s, line %i)", ptr, file, line);
+        free(ptr);
+}
diff --git a/common/eurephia_nullsafe.h b/common/eurephia_nullsafe.h
index fde8c2f..70c09d3 100644
--- a/common/eurephia_nullsafe.h
+++ b/common/eurephia_nullsafe.h
@@ -83,6 +83,9 @@ void *__malloc_nullsafe(eurephiaCTX *, size_t, const char *, int);
  */
 #define malloc_nullsafe(ctx, sz) __malloc_nullsafe(ctx, sz, __FILE__, __LINE__)
 
+
+void inline __free_nullsafe(eurephiaCTX *ctx, void *ptr, const char *file, int line);
+
 /**
  * free() wrapper.  Frees memory allocated by malloc() or calloc().  It also sets the
  * input pointer to NULL on success.
@@ -90,7 +93,7 @@ void *__malloc_nullsafe(eurephiaCTX *, size_t, const char *, int);
  * @param ptr Pointer to the memory region being freed.
  *
  */
-#define free_nullsafe(ptr) if( ptr != NULL ) { free(ptr); ptr = NULL; }
+#define free_nullsafe(ctx, ptr) { __free_nullsafe(ctx, ptr, __FILE__, __LINE__); ptr = NULL; }
 
 
 /**
diff --git a/common/eurephia_values.c b/common/eurephia_values.c
index 501b6ba..78f0e6a 100644
--- a/common/eurephia_values.c
+++ b/common/eurephia_values.c
@@ -46,9 +46,9 @@ void do_free_vals(eurephiaVALUES *vls) {
         if( vls->next != NULL ) {
                 do_free_vals(vls->next);
         }
-        free_nullsafe(vls->key);
-        free_nullsafe(vls->val);
-        free_nullsafe(vls);
+        free_nullsafe(NULL, vls->key);
+        free_nullsafe(NULL, vls->val);
+        free_nullsafe(NULL, vls);
 }
 
 
diff --git a/common/eurephia_xml.c b/common/eurephia_xml.c
index 8e34050..e78d2b3 100644
--- a/common/eurephia_xml.c
+++ b/common/eurephia_xml.c
@@ -60,11 +60,11 @@ char *xmlGetAttrValue(xmlAttr *attr, const char *key) {
         for( aptr = attr; aptr != NULL; aptr = aptr->next ) {
                 if( xmlStrcmp(aptr->name, x_key) == 0 ) {
                         // FIXME: Should find a better way to return UTF-8 data
-                        free_nullsafe(x_key);
+                        free_nullsafe(NULL, x_key);
                         return (char *)(aptr->children != NULL ? aptr->children->content : NULL);
                 }
         }
-        free_nullsafe(x_key);
+        free_nullsafe(NULL, x_key);
         return NULL;
 }
 
@@ -90,11 +90,11 @@ xmlNode *xmlFindNode(xmlNode *node, const char *key) {
 
         for( nptr = node->children; nptr != NULL; nptr = nptr->next ) {
                 if( xmlStrcmp(nptr->name, x_key) == 0 ) {
-                        free_nullsafe(x_key);
+                        free_nullsafe(NULL, x_key);
                         return nptr;
                 }
         }
-        free_nullsafe(x_key);
+        free_nullsafe(NULL, x_key);
         return NULL;
 }
 
@@ -193,7 +193,7 @@ xmlDoc *eurephiaXML_ResultMsg(eurephiaCTX *ctx, exmlResultType type, const char
         va_start(ap, fmt);
         xmlStrVPrintf(msg, 2048, xmlfmt, ap);
         va_end(ap);
-        free_nullsafe(xmlfmt);
+        free_nullsafe(ctx, xmlfmt);
 
         switch( type ) {
         case exmlRESULT:
diff --git a/common/eurephiadb_session_common.c b/common/eurephiadb_session_common.c
index a810bf0..9b65331 100644
--- a/common/eurephiadb_session_common.c
+++ b/common/eurephiadb_session_common.c
@@ -102,7 +102,7 @@ int eDBset_session_value(eurephiaCTX *ctx, eurephiaSESSION *session, const char
                 }
                 // Update the value in the stack if database is updated without errors
                 if( eDBstore_session_value(ctx, session,(val != NULL ? SESSVAL_UPDATE : SESSVAL_DELETE), key,val)){
-                        free_nullsafe(svals->val);
+                        free_nullsafe(ctx, svals->val);
                         svals->val = strdup_nullsafe(val);
                         DEBUG(ctx, 32, "Session variable updated in session '%s': %s = %s",
                               session->sessionkey, key, val);
@@ -127,6 +127,6 @@ void eDBfree_session_func(eurephiaCTX *ctx, eurephiaSESSION *session) {
         }
         DEBUG(ctx, 12, "Function call: eDBfree_session(ctx, '%s')", session->sessionkey);
         eFree_values(ctx, session->sessvals);
-        free_nullsafe(session->sessionkey);
+        free_nullsafe(ctx, session->sessionkey);
         free(session);
 }
diff --git a/common/passwd.c b/common/passwd.c
index 9820988..c3971f4 100644
--- a/common/passwd.c
+++ b/common/passwd.c
@@ -171,7 +171,7 @@ int gen_randsaltstr(eurephiaCTX *ctx, char *saltstr, int len) {
                 ptr++;
                 ptr2++;
         }
-        free_nullsafe(rand);
+        free_nullsafe(ctx, rand);
         return 1;
 }
 
@@ -579,7 +579,7 @@ char *eurephia_quick_hash(const char *salt, const char *pwd) {
         // Cleanup - remove hash data from memory
         memset(&sha, 0, sizeof(SHA512Context));
         memset(&sha_res, 0, sizeof(sha_res));
-        free_nullsafe(tmp);
+        free_nullsafe(NULL, tmp);
 
         return ret;
 }
diff --git a/database/eurephiadb_mapping.c b/database/eurephiadb_mapping.c
index fbb4584..52c9778 100644
--- a/database/eurephiadb_mapping.c
+++ b/database/eurephiadb_mapping.c
@@ -71,8 +71,8 @@ void eDBfreeMapping(eDBfieldMap *p) {
 
         // Release value and this pointer.
         // Do not attempt to release field_name, as it is a constant char *
-        free_nullsafe(p->value);
-        free_nullsafe(p->table_alias);
+        free_nullsafe(NULL, p->value);
+        free_nullsafe(NULL, p->table_alias);
         free(p);
 }
 
@@ -325,7 +325,7 @@ char *eDBmkSortKeyString(eDBfieldMap *tfmap, const char *skeys_str) {
                 }
                 tok = strtok(NULL, delims);
         }
-        free_nullsafe(cp);
+        free_nullsafe(NULL, cp);
         sortkeys[strlen(sortkeys)-1] = '\0';
         eDBfreeMapping(sk_map);
 
diff --git a/database/sqlite/administration.c b/database/sqlite/administration.c
index f3527c0..a8725b3 100644
--- a/database/sqlite/administration.c
+++ b/database/sqlite/administration.c
@@ -158,7 +158,7 @@ int eDBadminAuth(eurephiaCTX *ctx, const char *req_access, const char *uname, co
                         pwdok = ((crpwd != NULL) && (strcmp(crpwd, dbpwd) == 0) ? 1 : 0);
                         memset(crpwd, 0, strlen_nullsafe(crpwd));
                         memset(dbpwd, 0, strlen_nullsafe(dbpwd));
-                        free_nullsafe(crpwd);
+                        free_nullsafe(ctx, crpwd);
                         if( pwdok == 0 ) {
                                 eurephia_log(ctx, LOG_WARNING, 0, "Authentication failed.");
                                 sleep(2);
@@ -1356,7 +1356,7 @@ xmlDoc *eDBadminGetLastlog(eurephiaCTX *ctx, xmlDoc *srch, const char *sortkeys)
         for( fptr = fmap; fptr != NULL; fptr = fptr->next) {
                 switch( fptr->field_id ) {
                 case FIELD_UNAME:
-                        free_nullsafe(fptr->table_alias);
+                        free_nullsafe(ctx, fptr->table_alias);
                 default:
                         break;
                 }
diff --git a/database/sqlite/edb-sqlite.c b/database/sqlite/edb-sqlite.c
index c1aa1c0..d4ef84d 100644
--- a/database/sqlite/edb-sqlite.c
+++ b/database/sqlite/edb-sqlite.c
@@ -123,8 +123,8 @@ int eDBconnect(eurephiaCTX *ctx, const int argc, const char **argv)
         rc = sqlite3_open(argv[0], (void *) &dbc->dbhandle);
         if( rc ) {
                 eurephia_log(ctx, LOG_PANIC, 0, "Could not open database '%s'", dbc->dbname);
-                free_nullsafe(dbc->dbname);
-                free_nullsafe(dbc);
+                free_nullsafe(ctx, dbc->dbname);
+                free_nullsafe(ctx, dbc);
                 return 0;
         }
 
@@ -170,12 +170,12 @@ void eDBdisconnect(eurephiaCTX *ctx)
 
         // Close database connection
         sqlite3_close((sqlite3 *) dbc->dbhandle);
-        free_nullsafe(dbc->dbname);
+        free_nullsafe(ctx, dbc->dbname);
         dbc->dbhandle = NULL;
 
         // Free up config memory
         eFree_values(ctx, dbc->config);
-        free_nullsafe(dbc);
+        free_nullsafe(ctx, dbc);
         ctx->dbc = NULL;
 }
 
@@ -214,7 +214,7 @@ int eDBauth_TLS(eurephiaCTX *ctx, const char *org, const char *cname, const char
                         update_attempts(ctx, blid);
                         certid = -1;
                 }
-                free_nullsafe(blid);
+                free_nullsafe(ctx, blid);
         } else {
                 eurephia_log(ctx, LOG_FATAL, 0, "Could not look up certificate information");
         }
@@ -249,7 +249,7 @@ int eDBauth_user(eurephiaCTX *ctx, const int certid, const char *username, const
                            " WHERE uc.certid = '%i' AND ou.username = '%q'",
                            certid, username);
         memset(crpwd, 0, strlen_nullsafe(crpwd));
-        free_nullsafe(crpwd);
+        free_nullsafe(ctx, crpwd);
         if( res == NULL ) {
                 eurephia_log(ctx, LOG_FATAL, 0,
                              "Could not lookup user in database (certid %i, username '%s'", certid, username);
@@ -273,7 +273,7 @@ int eDBauth_user(eurephiaCTX *ctx, const int certid, const char *username, const
                         pwdok = ((crpwd != NULL) && (strcmp(crpwd, dbpwd) == 0) ? 1 : 0);
                         memset(crpwd, 0, strlen_nullsafe(crpwd));
                         memset(dbpwd, 0, strlen_nullsafe(dbpwd));
-                        free_nullsafe(crpwd);
+                        free_nullsafe(ctx, crpwd);
                 }
 
                 if( blid_uname != NULL ) {
@@ -414,14 +414,14 @@ int eDBblacklist_check(eurephiaCTX *ctx, const int type, const char *val)
                                 sqlite_free_results(blr);
                                 blacklisted = 1; // [type] is blacklisted
                         }
-                        free_nullsafe(atpid);
+                        free_nullsafe(ctx, atpid);
                 } else {
                         eurephia_log(ctx, LOG_CRITICAL, 0, "Quering openvpn_attempts for blacklisted %s failed",
                                      eDBattempt_types[type].descr);
                 }
-                free_nullsafe(atpr);
+                free_nullsafe(ctx, atpr);
         }
-        free_nullsafe(blid);
+        free_nullsafe(ctx, blid);
 
         DEBUG(ctx, 20, "Result - function call: eDBblacklist_check(ctx, '%s', '%s') - %i",
               eDBattempt_types[type].descr, val, blacklisted);
@@ -511,9 +511,9 @@ void eDBregister_attempt(eurephiaCTX *ctx, int type, int mode, const char *value
                 }
                 sqlite_free_results(res);
         }
-        free_nullsafe(id);
-        free_nullsafe(atmpt_block);
-        free_nullsafe(blid);
+        free_nullsafe(ctx, id);
+        free_nullsafe(ctx, atmpt_block);
+        free_nullsafe(ctx, blid);
 }
 
 
diff --git a/database/sqlite/sqlite.c b/database/sqlite/sqlite.c
index 5faa0b7..8646ea6 100644
--- a/database/sqlite/sqlite.c
+++ b/database/sqlite/sqlite.c
@@ -65,13 +65,13 @@ void _sqlite_free_results(dbresult *inres)
                         do {
                                 if( fld != fld->prevfield ) {
                                         fld = fld->nextfield;
-                                        free_nullsafe(fld->prevfield->value);
-                                        free_nullsafe(fld->prevfield);
+                                        free_nullsafe(NULL, fld->prevfield->value);
+                                        free_nullsafe(NULL, fld->prevfield);
                                 }
                         } while( fld != tup );
                         tup = tup->nexttuple;
-                        free_nullsafe(fld->value);
-                        free_nullsafe(fld);
+                        free_nullsafe(NULL, fld->value);
+                        free_nullsafe(NULL, fld);
                 } while( tup != inres->tuples );
         }
 
@@ -81,14 +81,14 @@ void _sqlite_free_results(dbresult *inres)
                 do {
                         if( hdr != hdr->prev ) {
                                 hdr = hdr->next;
-                                free_nullsafe(hdr->prev->name);
-                                free_nullsafe(hdr->prev);
+                                free_nullsafe(NULL, hdr->prev->name);
+                                free_nullsafe(NULL, hdr->prev);
                         }
                 } while( hdr != inres->headerrec );
-                free_nullsafe(hdr->name);
-                free_nullsafe(hdr);
+                free_nullsafe(NULL, hdr->name);
+                free_nullsafe(NULL, hdr);
         }
-        free_nullsafe(inres);
+        free_nullsafe(NULL, inres);
 }
 
 
@@ -232,7 +232,7 @@ dbresult *sqlite_query(eurephiaCTX *ctx, char *fmt, ... ) {
         if( rc != SQLITE_OK ) {
                 eurephia_log(ctx, LOG_ERROR, 0, "SQL Error: %s", errMsg);
                 sqlite3_free(sql); sql = NULL;
-                free_nullsafe(glob_results);
+                free_nullsafe(ctx, glob_results);
                 return NULL;
         }
 
@@ -430,7 +430,7 @@ dbresult *sqlite_query_mapped(eurephiaCTX *ctx, SQLqueryType qType, const char *
                                                    sqlstub, (strlen_nullsafe(tmp1) > 0 ? "WHERE" : ""), tmp1,
                                                    sortkeys);
                         }
-                        free_nullsafe(tmp1);
+                        free_nullsafe(ctx, tmp1);
                 }
                 break;
 
@@ -440,15 +440,15 @@ dbresult *sqlite_query_mapped(eurephiaCTX *ctx, SQLqueryType qType, const char *
                         tmp2 = _build_sqlpart(btWHERE, whereMap);
 
                         res = sqlite_query(ctx, "%s SET %s WHERE %s", sqlstub, tmp1, tmp2);
-                        free_nullsafe(tmp1);
-                        free_nullsafe(tmp2);
+                        free_nullsafe(ctx, tmp1);
+                        free_nullsafe(ctx, tmp2);
                 }
                 break;
 
         case SQL_INSERT:
                 tmp1 = _build_sqlpart(btINSERT, valMap);
                 res = sqlite_query(ctx, "%s %s", sqlstub, tmp1);
-                free_nullsafe(tmp1);
+                free_nullsafe(ctx, tmp1);
                 break;
        }
 
@@ -536,8 +536,8 @@ xmlNodePtr sqlite_xml_value(xmlNodePtr node, xmlFieldType xmltyp, char *inname,
                         retnode = NULL;
                 }
         }
-        free_nullsafe(data);
-        free_nullsafe(name);
+        free_nullsafe(NULL, data);
+        free_nullsafe(NULL, name);
         return retnode;
 }
 #endif
diff --git a/eurephiadm/client_config.c b/eurephiadm/client_config.c
index 8b24cf2..1629d82 100644
--- a/eurephiadm/client_config.c
+++ b/eurephiadm/client_config.c
@@ -121,7 +121,7 @@ eurephiaVALUES *parse_config_line(const char *line) {
         key = cp;
         val = strpbrk(cp, "=");
         if( val == NULL ) {
-                free_nullsafe(cp);
+                free_nullsafe(NULL, cp);
                 return NULL;
         }
         *val = '\0'; val++;
@@ -159,7 +159,7 @@ eurephiaVALUES *parse_config_line(const char *line) {
         ret->key = strdup(key);
         ret->val = strdup(val);
 
-        free_nullsafe(cp);
+        free_nullsafe(NULL, cp);
         return ret;
 }
 
@@ -205,7 +205,7 @@ eurephiaVALUES *ReadConfig(const char *env, const char *cfgname) {
                         eAdd_valuestruct(NULL, cfg, prm);
                 }
         };
-        free_nullsafe(buf);
+        free_nullsafe(NULL, buf);
         fclose(fp); fp = NULL;
 
         return cfg;
diff --git a/eurephiadm/client_context.c b/eurephiadm/client_context.c
index 6875087..aaec995 100644
--- a/eurephiadm/client_context.c
+++ b/eurephiadm/client_context.c
@@ -76,7 +76,7 @@ eurephiaCTX *eurephiaCTX_init(FILE *log, const int loglevel, eurephiaVALUES *cfg
                         ctx->log = NULL;
                 } else if( (ctx->log = fopen(logfile, "aw")) == NULL ) {
                         fprintf(stderr, "ERROR: Could not open log file: %s\n", logfile);
-                        free_nullsafe(ctx);
+                        free_nullsafe(NULL, ctx);
                         return NULL;
                 }
         } else {
@@ -99,7 +99,7 @@ eurephiaCTX *eurephiaCTX_init(FILE *log, const int loglevel, eurephiaVALUES *cfg
 
         if( !eDBlink_init(ctx, dbdriver, 2) ) {
                 eurephia_log(ctx, LOG_PANIC, 0, "Could not load the database driver");
-                free_nullsafe(ctx);
+                free_nullsafe(ctx, ctx);
                 return NULL;
         }
         return ctx;
@@ -137,5 +137,5 @@ void eurephiaCTX_destroy(eurephiaCTX *ctx) {
                 ctx->log = NULL;
                 ctx->loglevel = 0;
         }
-        free_nullsafe(ctx);
+        free_nullsafe(ctx, ctx);
 }
diff --git a/eurephiadm/client_session.c b/eurephiadm/client_session.c
index 0f3ec80..22334c2 100644
--- a/eurephiadm/client_session.c
+++ b/eurephiadm/client_session.c
@@ -177,15 +177,15 @@ eurephiaSESSION *create_session(eurephiaCTX *ctx, const char *sesskey) {
                         if( !eurephia_randstring(ctx, randdata, 512) ) {
                                 eurephia_log(ctx, LOG_FATAL, 0,
                                              "Could not generate enough random data for session");
-                                free_nullsafe(randdata);
-                                free_nullsafe(new_sess);
+                                free_nullsafe(ctx, randdata);
+                                free_nullsafe(ctx, new_sess);
                                 return NULL;
                         }
 
                         memset(&sha, 0, sizeof(SHA512Context));
                         memset(&sha_res, 0, SHA512_HASH_SIZE+2);
 
-                        free_nullsafe(new_sess->sessionkey);
+                        free_nullsafe(ctx, new_sess->sessionkey);
                         new_sess->sessionkey = (char *) malloc_nullsafe(ctx, (SHA512_HASH_SIZE*2) + 3);
                         assert(new_sess->sessionkey != NULL);
 
@@ -205,14 +205,14 @@ eurephiaSESSION *create_session(eurephiaCTX *ctx, const char *sesskey) {
                         uniqchk = eDBcheck_sessionkey_uniqueness(ctx, new_sess->sessionkey);
                         memset(randdata, 0, 514);
                 } while( (uniqchk == 0) && (loop < 11) );
-                free_nullsafe(randdata);
+                free_nullsafe(ctx, randdata);
 
                 if( uniqchk == 0 ) {
                         eurephia_log(ctx, LOG_FATAL, 0,
                                      "Did not manage to create a unique session key after %i attempts."
                                      "  Aborting.", loop-1);
-                        free_nullsafe(new_sess->sessionkey);
-                        free_nullsafe(new_sess);
+                        free_nullsafe(ctx, new_sess->sessionkey);
+                        free_nullsafe(ctx, new_sess);
                         return NULL;
                 }
         } else {
diff --git a/eurephiadm/commands/adminaccess.c b/eurephiadm/commands/adminaccess.c
index 179db97..f0daf61 100644
--- a/eurephiadm/commands/adminaccess.c
+++ b/eurephiadm/commands/adminaccess.c
@@ -391,7 +391,7 @@ int cmd_AdminAccess(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg
 
         // Call the mode function
         rc = mode_fnc(ctx, sess, cfg, mode_argc, mode_argv);
-        free_nullsafe(mode_argv);
+        free_nullsafe(ctx, mode_argv);
 
         return rc;
 }
diff --git a/eurephiadm/commands/attempts.c b/eurephiadm/commands/attempts.c
index 75cbdd6..0ce6455 100644
--- a/eurephiadm/commands/attempts.c
+++ b/eurephiadm/commands/attempts.c
@@ -371,7 +371,7 @@ int cmd_Attempts(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, i
 
         // Call the mode function
         rc = mode_fnc(ctx, sess, cfg, mode_argc, mode_argv);
-        free_nullsafe(mode_argv);
+        free_nullsafe(ctx, mode_argv);
 
         return rc;
 
diff --git a/eurephiadm/commands/blacklist.c b/eurephiadm/commands/blacklist.c
index 69d5962..8227a18 100644
--- a/eurephiadm/commands/blacklist.c
+++ b/eurephiadm/commands/blacklist.c
@@ -371,7 +371,7 @@ int cmd_Blacklist(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg,
 
         // Call the mode function
         rc = mode_fnc(ctx, sess, cfg, mode_argc, mode_argv);
-        free_nullsafe(mode_argv);
+        free_nullsafe(ctx, mode_argv);
 
         return rc;
 
diff --git a/eurephiadm/commands/certificates.c b/eurephiadm/commands/certificates.c
index 5e81e06..469d28d 100644
--- a/eurephiadm/commands/certificates.c
+++ b/eurephiadm/commands/certificates.c
@@ -200,8 +200,8 @@ int register_certificate(eurephiaCTX *ctx, int depth, const char *digest,
                 fprintf(stderr, "%s: Failed to register certificate\n", MODULE);
         }
         xmlFreeDoc(cert_xml);
-        free_nullsafe(cname_cp);
-        free_nullsafe(org_cp);
+        free_nullsafe(ctx, cname_cp);
+        free_nullsafe(ctx, org_cp);
 
         return certid;
 }
@@ -354,10 +354,10 @@ int add_cert(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, int a
         // register_certificate returns value < 1, it means registration failed => rc = 1
         rc = (register_certificate(ctx, depth, digest, cname, org, email) < 1);
  exit:
-        free_nullsafe(digest);
-        free_nullsafe(cname);
-        free_nullsafe(org);
-        free_nullsafe(email);
+        free_nullsafe(ctx, digest);
+        free_nullsafe(ctx, cname);
+        free_nullsafe(ctx, org);
+        free_nullsafe(ctx, email);
         return rc;
 }
 
@@ -492,8 +492,8 @@ int delete_cert(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, in
  exit:
         xmlFreeDoc(certlist);
         xmlFreeDoc(cert_xml);
-        free_nullsafe(cname);
-        free_nullsafe(org);
+        free_nullsafe(ctx, cname);
+        free_nullsafe(ctx, org);
         return rc;
 }
 
@@ -640,7 +640,7 @@ int cmd_Certificates(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cf
 
         // Call the mode function
         rc = mode_fnc(ctx, sess, cfg, mode_argc, mode_argv);
-        free_nullsafe(mode_argv);
+        free_nullsafe(ctx, mode_argv);
 
         return rc;
 }
diff --git a/eurephiadm/commands/fwprofiles.c b/eurephiadm/commands/fwprofiles.c
index 4eac0f1..3f79017 100644
--- a/eurephiadm/commands/fwprofiles.c
+++ b/eurephiadm/commands/fwprofiles.c
@@ -398,7 +398,7 @@ int cmd_fwProfiles(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg,
 
         // Call the mode function
         rc = mode_fnc(ctx, sess, cfg, mode_argc, mode_argv);
-        free_nullsafe(mode_argv);
+        free_nullsafe(ctx, mode_argv);
 
         return rc;
 
diff --git a/eurephiadm/commands/usercerts.c b/eurephiadm/commands/usercerts.c
index a86d232..208f816 100644
--- a/eurephiadm/commands/usercerts.c
+++ b/eurephiadm/commands/usercerts.c
@@ -542,7 +542,7 @@ int cmd_UserCerts(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg,
 
         // Call the mode function
         rc = mode_fnc(ctx, sess, cfg, mode_argc, mode_argv);
-        free_nullsafe(mode_argv);
+        free_nullsafe(ctx, mode_argv);
 
         return rc;
 }
diff --git a/eurephiadm/commands/users.c b/eurephiadm/commands/users.c
index 66b3bce..7e6c215 100644
--- a/eurephiadm/commands/users.c
+++ b/eurephiadm/commands/users.c
@@ -567,20 +567,20 @@ int account_activation(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *
 
                         get_console_input(newpwd, 64, "Password for user:", 1);
                         if( strlen_nullsafe(newpwd) < 4 ) {
-                                free_nullsafe(newpwd);
-                                free_nullsafe(chkpwd);
+                                free_nullsafe(ctx, newpwd);
+                                free_nullsafe(ctx, chkpwd);
                                 fprintf(stderr, "%s: Password is too short\n", MODULE);
                                 goto exit;
                         }
 
                         get_console_input(chkpwd, 64, "Verify password for user:", 1);
                         if( strcmp(newpwd, chkpwd) != 0 ) {
-                                free_nullsafe(newpwd);
-                                free_nullsafe(chkpwd);
+                                free_nullsafe(ctx, newpwd);
+                                free_nullsafe(ctx, chkpwd);
                                 fprintf(stderr, "%s: Passwords didn't match\n", MODULE);
                                 goto exit;
                         }
-                        free_nullsafe(chkpwd);
+                        free_nullsafe(ctx, chkpwd);
                 }
 
                 // Update with new password
@@ -588,7 +588,7 @@ int account_activation(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *
                 xmlNewProp(tmp_n, (xmlChar *) "pwhash", (xmlChar *) "none");
                 rc = eDBadminUpdateUser(ctx, atoi_nullsafe(uid_str), update_xml);
 
-                free_nullsafe(newpwd);
+                free_nullsafe(ctx, newpwd);
                 break;
 
         case 'D':  // Delete user account
@@ -759,20 +759,20 @@ int add_user(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, int a
 
                 get_console_input(passwd, 64, "Password for user:", 1);
                 if( strlen_nullsafe(passwd) < 4 ) {
-                        free_nullsafe(passwd);
-                        free_nullsafe(chkpwd);
+                        free_nullsafe(ctx, passwd);
+                        free_nullsafe(ctx, chkpwd);
                         fprintf(stderr, "%s: Password is too short\n", MODULE);
                         return 1;
                 }
 
                 get_console_input(chkpwd, 64, "Verify password for user:", 1);
                 if( strcmp(passwd, chkpwd) != 0 ) {
-                        free_nullsafe(passwd);
-                        free_nullsafe(chkpwd);
+                        free_nullsafe(ctx, passwd);
+                        free_nullsafe(ctx, chkpwd);
                         fprintf(stderr, "%s: Passwords didn't match\n", MODULE);
                         return 1;
                 }
-                free_nullsafe(chkpwd);
+                free_nullsafe(ctx, chkpwd);
         }
 
 
@@ -793,7 +793,7 @@ int add_user(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, int a
                 fprintf(stderr, "%s: Failed to register user\n", MODULE);
         }
         memset(passwd, 0, strlen_nullsafe(passwd));
-        free_nullsafe(passwd);
+        free_nullsafe(ctx, passwd);
         xmlFreeDoc(user_xml);
 
         if( (digest != NULL) || (certfile != NULL) ) {
@@ -991,7 +991,7 @@ int cmd_Users(eurephiaCTX *ctx, eurephiaSESSION *sess, eurephiaVALUES *cfg, int
 
         // Call the mode function
         rc = mode_fnc(ctx, sess, cfg, mode_argc, mode_argv);
-        free_nullsafe(mode_argv);
+        free_nullsafe(ctx, mode_argv);
 
         return rc;
 }
diff --git a/eurephiadm/eurephiadm.c b/eurephiadm/eurephiadm.c
index 10cf70e..518f8a5 100644
--- a/eurephiadm/eurephiadm.c
+++ b/eurephiadm/eurephiadm.c
@@ -232,7 +232,7 @@ int eurephia_ConnectDB(eurephiaCTX *ctx, const char *argstr) {
                 eDBlink_close(ctx);
                 return 0;
         }
-        free_nullsafe(cp);
+        free_nullsafe(ctx, cp);
        
         return 1;
 }
@@ -467,7 +467,7 @@ int main(int argc, char **argv) {
                         char *logout_argv[] = { sesskey_file };
                         rc = cmd_Logout(ctx, NULL, cfg, 0, logout_argv);
                         remove_session_file(ctx);
-                        free_nullsafe(sesskey_file);
+                        free_nullsafe(ctx, sesskey_file);
                         goto exit;
                 }
 
@@ -484,7 +484,7 @@ int main(int argc, char **argv) {
                         }
                 }
         }
-        free_nullsafe(sesskey_file);
+        free_nullsafe(ctx, sesskey_file);
 
 
         // If we have an open session now, call the requested command
@@ -500,7 +500,7 @@ int main(int argc, char **argv) {
                 rc = call_fnc->function(ctx, session, cfg, cmdargc, cmdargv);
                 argstr = args2string(cmdargc, cmdargv);
                 eurephia_log(ctx, LOG_INFO, 0, "Command: %s (result: %i)", argstr, rc);
-                free_nullsafe(argstr);
+                free_nullsafe(ctx, argstr);
 
                 // Remove session info from memory
                 eDBfree_session(ctx, session);
diff --git a/plugin/eurephia.c b/plugin/eurephia.c
index 82a3097..761ab71 100644
--- a/plugin/eurephia.c
+++ b/plugin/eurephia.c
@@ -221,7 +221,7 @@ eurephiaCTX *eurephiaInit(const char **argv)
                         eurephia_log(ctx, LOG_PANIC, 0, "eurephia-auth is not available");
                         fclose(ctx->log);
                 }
-                free_nullsafe(ctx);
+                free_nullsafe(ctx, ctx);
                 return NULL;
         }
 
@@ -232,10 +232,10 @@ eurephiaCTX *eurephiaInit(const char **argv)
         if( !eurephia_randstring(ctx, ctx->server_salt, SIZE_PWDCACHE_SALT) ) {
                 eurephia_log(ctx, LOG_PANIC, 0 , "Could not get enough random data for password cache.");
 
-                free_nullsafe(ctx->server_salt);
+                free_nullsafe(ctx, ctx->server_salt);
                 eDBdisconnect(ctx);
                 fclose(ctx->log);
-                free_nullsafe(ctx);
+                free_nullsafe(ctx, ctx);
                 return NULL;
         }
 
@@ -301,8 +301,8 @@ int eurephiaShutdown(eurephiaCTX *ctx)
         }
 
         memset(ctx->server_salt, 0xff, SIZE_PWDCACHE_SALT+2);
-        free_nullsafe(ctx->server_salt);
-        free_nullsafe(ctx);
+        free_nullsafe(ctx, ctx->server_salt);
+        free_nullsafe(ctx, ctx);
         return 1;
 }
 
@@ -487,7 +487,7 @@ int eurephia_userauth(eurephiaCTX *ctx, const char **env)
         }
 
  exit:
-        free_nullsafe(chkpwd);
+        free_nullsafe(ctx, chkpwd);
         eDBfree_session(ctx, authsess);
         DEBUG(ctx, 10, "** Function result: eurephia_userauth(...) = %i", (result>0));
         return (result > 0);
@@ -652,7 +652,7 @@ int eurephia_learn_address(eurephiaCTX *ctx, const char *mode, const char *macad
                         fwprofile = eDBget_firewall_profile(ctx, session);
                         if( fwprofile != NULL ) {
                                 eFW_UpdateFirewall(ctx, FWRULE_ADD, macaddr, fwdest, fwprofile);
-                                free_nullsafe(fwprofile);
+                                free_nullsafe(ctx, fwprofile);
                         }
                 }
                 eDBfree_session(ctx, session);
@@ -673,7 +673,7 @@ int eurephia_learn_address(eurephiaCTX *ctx, const char *mode, const char *macad
                         fwprofile = eDBget_firewall_profile(ctx, session);
                         if( fwprofile != NULL ) {
                                 eFW_UpdateFirewall(ctx, FWRULE_DELETE, macaddr, fwdest, fwprofile);
-                                free_nullsafe(fwprofile);
+                                free_nullsafe(ctx, fwprofile);
                         }
                 }
                 ret = eDBdestroy_session(ctx, session);
diff --git a/plugin/eurephiadb_session.c b/plugin/eurephiadb_session.c
index aca3b28..c0a6878 100644
--- a/plugin/eurephiadb_session.c
+++ b/plugin/eurephiadb_session.c
@@ -99,7 +99,7 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
 
         seeddata = (char *) malloc_nullsafe(ctx, (totlen * 2) + 4);
         if( seeddata == NULL ) {
-                free_nullsafe(new_session);
+                free_nullsafe(ctx, new_session);
                 return NULL;
         }
         snprintf((char *)seeddata, totlen,
@@ -114,8 +114,8 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
 
         seed = (char *) malloc_nullsafe(ctx, (SHA512_HASH_SIZE*2)+3);
         if( seed == NULL ) {
-                free_nullsafe(seeddata);
-                free_nullsafe(new_session);
+                free_nullsafe(ctx, seeddata);
+                free_nullsafe(ctx, new_session);
                 return NULL;
         }
         ptr = seed;
@@ -143,10 +143,10 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
                 // Loop until we get a unique sessionkey - don't loop more than 10 times
                 skeydata = (char *) malloc_nullsafe(ctx, (totlen*2)+4);
                 if( skeydata == NULL ) {
-                        free_nullsafe(new_session->sessionkey);
-                        free_nullsafe(new_session);
-                        free_nullsafe(seeddata);
-                        free_nullsafe(seed);
+                        free_nullsafe(ctx, new_session->sessionkey);
+                        free_nullsafe(ctx, new_session);
+                        free_nullsafe(ctx, seeddata);
+                        free_nullsafe(ctx, seed);
                         return NULL;
                 }
                 do {
@@ -157,10 +157,10 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
                         // Append some random data to our session seed
                         rndstr = (char *) malloc_nullsafe(ctx, (totlen * 2));
                         if( rndstr == NULL ) {
-                                free_nullsafe(new_session->sessionkey);
-                                free_nullsafe(new_session);
-                                free_nullsafe(seeddata);
-                                free_nullsafe(seed);
+                                free_nullsafe(ctx, new_session->sessionkey);
+                                free_nullsafe(ctx, new_session);
+                                free_nullsafe(ctx, seeddata);
+                                free_nullsafe(ctx, seed);
                                 return NULL;
                         }
                         rndlen = ((totlen * 2) - strlen_nullsafe(seed) - 2);
@@ -168,10 +168,10 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
                         if( !eurephia_randstring(ctx, rndstr, rndlen) ) {
                                 eurephia_log(ctx, LOG_PANIC, 0,
                                              "Could not generate enough random data for session key");
-                                free_nullsafe(new_session->sessionkey);
-                                free_nullsafe(new_session);
-                                free_nullsafe(seeddata);
-                                free_nullsafe(seed);
+                                free_nullsafe(ctx, new_session->sessionkey);
+                                free_nullsafe(ctx, new_session);
+                                free_nullsafe(ctx, seeddata);
+                                free_nullsafe(ctx, seed);
                                 return NULL;
                         }
 
@@ -180,12 +180,12 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
                         SHA512Update(&sha, rndstr, rndlen);
                         SHA512Final(&sha, sha_res);
 
-                        free_nullsafe(new_session->sessionkey);
+                        free_nullsafe(ctx, new_session->sessionkey);
                         new_session->sessionkey = (char *) malloc_nullsafe(ctx, (SHA512_HASH_SIZE*2)+3);
                         if( new_session->sessionkey == NULL ) {
-                                free_nullsafe(new_session);
-                                free_nullsafe(seeddata);
-                                free_nullsafe(seed);
+                                free_nullsafe(ctx, new_session);
+                                free_nullsafe(ctx, seeddata);
+                                free_nullsafe(ctx, seed);
                                 return NULL;
                         }
 
@@ -196,31 +196,31 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
                         }
                         memset(&sha, 0, sizeof(SHA512Context));
                         memset(&sha_res, 0, sizeof(sha_res));
-                        free_nullsafe(rndstr);
+                        free_nullsafe(ctx, rndstr);
 
                         loop++;
                         uniqcheck = eDBcheck_sessionkey_uniqueness(ctx, new_session->sessionkey);
                 } while( (uniqcheck == 0) && loop < 11 );
-                free_nullsafe(skeydata);
+                free_nullsafe(ctx, skeydata);
 
                 // If we did not manage to create a unique session key (random data collection must have failed!)
                 if( uniqcheck == 0 ) {
                         eurephia_log(ctx, LOG_FATAL, 0,
                                      "Did not manage to create a unique sessionkey after %i attempts", loop-1);
-                        free_nullsafe(new_session->sessionkey);
-                        free_nullsafe(new_session);
-                        free_nullsafe(seeddata);
-                        free_nullsafe(seed);
+                        free_nullsafe(ctx, new_session->sessionkey);
+                        free_nullsafe(ctx, new_session);
+                        free_nullsafe(ctx, seeddata);
+                        free_nullsafe(ctx, seed);
                         return NULL;
                 }
 
                 // Save this session key in the database and connect it to this session seed
                 if( eDBregister_sessionkey(ctx, seed, new_session->sessionkey) == 0) {
                         eurephia_log(ctx, LOG_FATAL, 0, "Could not register sessionkey");
-                        free_nullsafe(new_session->sessionkey);
-                        free_nullsafe(new_session);
-                        free_nullsafe(seeddata);
-                        free_nullsafe(seed);
+                        free_nullsafe(ctx, new_session->sessionkey);
+                        free_nullsafe(ctx, new_session);
+                        free_nullsafe(ctx, seeddata);
+                        free_nullsafe(ctx, seed);
                         return NULL;
                 };
                 new_session->sessionstatus = SESSION_NEW;
@@ -228,8 +228,8 @@ eurephiaSESSION *eDBopen_session_seed(eurephiaCTX *ctx, const char *digest,
                 new_session->sessionstatus = SESSION_EXISTING;
                 DEBUG(ctx, 13, "Session seed found, using sessionkey '%s'", new_session->sessionkey);
         }
-        free_nullsafe(seed);
-        free_nullsafe(seeddata);
+        free_nullsafe(ctx, seed);
+        free_nullsafe(ctx, seeddata);
 
         // Load session values from the database
         new_session->sessvals = eDBload_sessiondata(ctx, new_session->sessionkey);
@@ -267,7 +267,7 @@ eurephiaSESSION *eDBopen_session_macaddr(eurephiaCTX *ctx, const char *macaddr)
         if( new_session->sessionkey == NULL ) {
                 eurephia_log(ctx, LOG_CRITICAL, 0, "Could not find an active session for MAC address '%s'",
                              macaddr);
-                free_nullsafe(new_session);
+                free_nullsafe(ctx, new_session);
                 return NULL;
         }
         DEBUG(ctx, 13, "Session seed found, using sessionkey '%s'", new_session->sessionkey);
diff --git a/plugin/firewall/eurephiafw.c b/plugin/firewall/eurephiafw.c
index 10d48a7..0d2cc43 100644
--- a/plugin/firewall/eurephiafw.c
+++ b/plugin/firewall/eurephiafw.c
@@ -193,13 +193,13 @@ void eFW_StartFirewall(eurephiaCTX *ctx) {
 
         // Setup semaphores we need
         if( efwSetupSemaphores(ctx, &(*ctx->fwcfg).thrdata) == 0 ) {
-                free_nullsafe(ctx->fwcfg->thrdata.fw_command);
+                free_nullsafe(ctx, ctx->fwcfg->thrdata.fw_command);
                 return;
         };
 
         // Setup a message queue
         if( efwSetupMessageQueue(ctx, &(*ctx->fwcfg).thrdata) == 0 ) {
-                free_nullsafe(ctx->fwcfg);
+                free_nullsafe(ctx, ctx->fwcfg);
                 return;
         }
 
@@ -349,10 +349,10 @@ void eFW_StopFirewall(eurephiaCTX *ctx) {
         sem_post(ctx->fwcfg->thrdata.semp_master);
 
         // Clean up and exit
-        free_nullsafe(ctx->fwcfg->fwblacklist_sendto);
+        free_nullsafe(ctx, ctx->fwcfg->fwblacklist_sendto);
         eFree_values(ctx, ctx->fwcfg->blacklisted);
-        free_nullsafe((*ctx->fwcfg).thrdata.fw_command);
-        free_nullsafe(ctx->fwcfg);
+        free_nullsafe(ctx, (*ctx->fwcfg).thrdata.fw_command);
+        free_nullsafe(ctx, ctx->fwcfg);
         eurephia_log(ctx, LOG_INFO, 2, "eurephia firewall interface is stopped");
 }
 
diff --git a/plugin/firewall/iptables/efw-iptables.c b/plugin/firewall/iptables/efw-iptables.c
index 1329973..5d04d83 100644
--- a/plugin/firewall/iptables/efw-iptables.c
+++ b/plugin/firewall/iptables/efw-iptables.c
@@ -303,7 +303,7 @@ int process_input(eurephiaCTX *ctx, const char *fwcmd, const char *input) {
                 eurephia_log(ctx, LOG_CRITICAL, 0, "eFW_RunFirewall::process_input:  Malformed update request");
 		ret = 1;
         }
-	free_nullsafe(orig_msg);
+	free_nullsafe(ctx, orig_msg);
 	return ret;
 }
 
diff --git a/utils/benchmark.c b/utils/benchmark.c
index fb1af80..a3fc5f1 100644
--- a/utils/benchmark.c
+++ b/utils/benchmark.c
@@ -69,7 +69,7 @@ void benchmark_hashing(int rounds) {
 
         pwdhash = sha512_crypt_r("benchmarkpassword", pwdsalt, ROUNDS_MAX, buffer, 1024);
 
-        free_nullsafe(buffer);
+        free_nullsafe(NULL, buffer);
 }
 
 
diff --git a/utils/eurephia_init.c b/utils/eurephia_init.c
index 8a3b343..b89ed75 100644
--- a/utils/eurephia_init.c
+++ b/utils/eurephia_init.c
@@ -132,7 +132,7 @@ int eurephia_ConnectDB(eurephiaCTX *ctx, eurephiaVALUES *cfg) {
                 eDBlink_close(ctx);
                 return 0;
         }
-        free_nullsafe(cp);
+        free_nullsafe(ctx, cp);
 
         return 1;
 }