Add a function to destroy a MeshLink instance.

This will remove all configuration files related to a MeshLink instance.

diff --git a/src/meshlink++.h b/src/meshlink++.h
index f1a3b96270e44fb084c1a7648df4bef50a45832e..8e0745e4869163bc0fe43688e2712f930ccb1b99 100644 (file)
--- a/src/meshlink++.h
+++ b/src/meshlink++.h
@@ -540,6 +540,19 @@ namespace meshlink {
                return meshlink_strerror(err);
        }
 
+       /// Destroy a MeshLink instance.
+       /** This function remove all configuration files of a MeshLink instance. It should only be called when the application
+        *  does not have an open handle to this instance. Afterwards, a call to meshlink_open() will create a completely
+        *  new instance.
+        *
+        *  @param confbase The directory in which MeshLink stores its configuration files.
+        *                  After the function returns, the application is free to overwrite or free @a confbase @a.
+        *
+        *  @return         This function will return true if the MeshLink instance was succesfully destroyed, false otherwise.
+        */
+       static bool destroy(const char *confbase) {
+               return meshlink_destroy(confbase);
+       }
 }
 
 #endif // MESHLINKPP_H

diff --git a/src/meshlink.c b/src/meshlink.c
index cbbb64d3728abe7ca3121237ebfe50800c9bbfb9..e9250e2509efd15e920e6ddc04c379d535fef00b 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -1049,6 +1049,49 @@ void meshlink_close(meshlink_handle_t *mesh) {
        free(mesh);
 }
 
+static void deltree(const char *dirname) {
+       DIR *d = opendir(dirname);
+       if(d) {
+               struct dirent *ent;
+               while((ent = readdir(d))) {
+                       if(ent->d_name[0] == '.')
+                               continue;
+                       char filename[PATH_MAX];
+                       snprintf(filename, sizeof filename, "%s" SLASH "%s", dirname, ent->d_name);
+                       if(unlink(filename))
+                               deltree(filename);
+               }
+               closedir(d);
+       }
+       rmdir(dirname);
+       return;
+}
+
+bool meshlink_destroy(const char *confbase) {
+       if(!confbase) {
+               meshlink_errno = MESHLINK_EINVAL;
+               return false;
+       }
+
+       char filename[PATH_MAX];
+       snprintf(filename, sizeof filename, "%s" SLASH "meshlink.conf", confbase);
+
+       if(unlink(filename)) {
+               if(errno == ENOENT) {
+                       meshlink_errno = MESHLINK_ENOENT;
+                       return false;
+               } else {
+                       logger(NULL, MESHLINK_ERROR, "Cannot delete %s: %s\n", filename, strerror(errno));
+                       meshlink_errno = MESHLINK_ESTORAGE;
+                       return false;
+               }
+       }
+
+       deltree(confbase);
+
+       return true;
+}
+
 void meshlink_set_receive_cb(meshlink_handle_t *mesh, meshlink_receive_cb_t cb) {
        if(!mesh) {
                meshlink_errno = MESHLINK_EINVAL;

diff --git a/src/meshlink.h b/src/meshlink.h
index 1f4bb7262e6b3780e9fac55cea784fde8dd1bca1..cca5db1aae10c43c5c71ac1e42b4517045433cce 100644 (file)
--- a/src/meshlink.h
+++ b/src/meshlink.h
@@ -196,6 +196,18 @@ extern void meshlink_stop(meshlink_handle_t *mesh);
  */
 extern void meshlink_close(meshlink_handle_t *mesh);
 
+/// Destroy a MeshLink instance.
+/** This function remove all configuration files of a MeshLink instance. It should only be called when the application
+ *  does not have an open handle to this instance. Afterwards, a call to meshlink_open() will create a completely
+ *  new instance.
+ *
+ *  @param confbase The directory in which MeshLink stores its configuration files.
+ *                  After the function returns, the application is free to overwrite or free @a confbase @a.
+ *
+ *  @return         This function will return true if the MeshLink instance was succesfully destroyed, false otherwise.
+ */
+extern bool meshlink_destroy(const char *confbase);
+
 /// A callback for receiving data from the mesh.
 /** @param mesh      A handle which represents an instance of MeshLink.
  *  @param source    A pointer to a meshlink_node_t describing the source of the data.

diff --git a/test/basic.c b/test/basic.c
index 626d06f6270e885a3133dd0b5819567a0b2d676a..93b7f5e99462199b7520a52a11f90bed85344e69 100644 (file)
--- a/test/basic.c
+++ b/test/basic.c
@@ -1,5 +1,7 @@
 #include <stdio.h>
 #include <string.h>
+#include <unistd.h>
+#include <errno.h>
 
 #include "meshlink.h"
 
@@ -79,5 +81,17 @@ int main(int argc, char *argv[]) {
 
        meshlink_close(mesh);
 
+       // Destroy the mesh.
+
+       if(!meshlink_destroy("basic_conf")) {
+               fprintf(stderr, "Could not destroy configuration\n");
+               return 1;
+       }
+
+       if(!access("basic_conf", F_OK) || errno != ENOENT) {
+               fprintf(stderr, "Configuration not fully destroyed\n");
+               return 1;
+       }
+
        return 0;
 }

diff --git a/test/basicpp.cpp b/test/basicpp.cpp
index 34c0bacbf2a7b45d13b227a99378d3bbb0af67a9..3a0c75ac016fd4db7a5bf25a26c93b55be0e4246 100644 (file)
--- a/test/basicpp.cpp
+++ b/test/basicpp.cpp
@@ -1,5 +1,7 @@
 #include <cstring>
 #include <iostream>
+#include <unistd.h>
+#include <cerrno>
 
 #include "meshlink++.h"
 
@@ -71,5 +73,15 @@ int main(int argc, char *argv[]) {
 
        mesh.stop();
 
+       if(!meshlink::destroy("basicpp_conf")) {
+               cerr << "Could not destroy configuration\n";
+               return 1;
+       }
+
+       if(!access("basic.conf", F_OK) || errno != ENOENT) {
+               cerr << "Configuration not fully destroyed\n";
+               return 1;
+       }
+
        return 0;
 }