Recursive listUSBdev.()

software/infnoise.c

@@ -16,8 +16,6 @@
 #include <string.h>
 #include <signal.h>
 #include <time.h>
-#include <sys/types.h>
-#include <ftdi.h> // requires <sys/types.h>
 #include <getopt.h>
 #include "infnoise.h"
 #include "libinfnoise.h"
@@ -223,19 +221,19 @@ int main(int argc, char **argv) {
     }
 
     if (opts.listDevices) {
-        devlist_node devlist = listUSBDevices(&context.message);
+        infnoise_devlist_node_t* devlist = listUSBDevices(&context.message);
         if (devlist == NULL) {
             fprintf(stderr, "Error: %s\n", context.message);
             return 1;
         }
-        devlist_node curdev;
+        infnoise_devlist_node_t* curdev;
-        for (curdev = devlist; curdev != NULL; ) {
+        int id = 0;
+        for (curdev = devlist; curdev != NULL; id++) {
             printf("ID: %i, Manufacturer: %s, Description: %s, Serial: %s\n",
-                   curdev->id, curdev->manufacturer,
+                   id, curdev->manufacturer, curdev->description, curdev->serial);
-                   curdev->description, curdev->serial);
 
             // cleanup:
-            devlist_node olddev = curdev;
+            infnoise_devlist_node_t* olddev = curdev;
             curdev = curdev->next;
             free(olddev);
         }

software/infnoise.h

@@ -6,7 +6,6 @@
 #else
 #include <linux/limits.h>
 #endif
-#include <ftdi.h>
 
 // Structure for parsed command line options
 struct opt_struct {

software/libinfnoise.c

@@ -198,51 +198,75 @@ bool isSuperUser(void) {
     return (geteuid() == 0);
 }
 
+
+// let's do it recursive, because if sth. fails we can easily wipe the malloc()
+infnoise_devlist_node_t* inf_get_devstrings(struct ftdi_context* ftdic,
+                                            struct ftdi_device_list* curdev,
+                                            char** message,
+                                            infnoise_devlist_node_t* bgn,
+                                            infnoise_devlist_node_t* end) {
+    if( curdev != NULL ) {
+        infnoise_devlist_node_t* cur;
+        cur = (infnoise_devlist_node_t*) malloc (sizeof(infnoise_devlist_node_t));
+        cur->next = NULL;
+        int rc = ftdi_usb_get_strings(ftdic, curdev->dev,
+                                      cur->manufacturer, sizeof(cur->manufacturer),
+                                      cur->description, sizeof(cur->description),
+                                      cur->serial, sizeof(cur->serial));
+        if (rc < 0) {
+            if (!isSuperUser()) {
+                *message = "Can't find Infinite Noise Multiplier. Try running as super user?";
+            } else {
+                sprintf(*message, "ftdi_usb_get_strings failed: %d (%s)", rc, ftdi_get_error_string(ftdic));
+            }
+            free( cur );
+            return NULL;
+        }
+        else {
+            // in case bgn is NULL, then implicitly end is NULL, also the other way around
+            if(bgn == NULL) {
+                bgn = cur;
+            }
+            else {
+                end->next = cur;
+            }
+            infnoise_devlist_node_t* ret;
+            ret = inf_get_devstrings(ftdic, curdev->next, message, bgn, cur);
+            // a next dev triggered issue? -> wipe current
+            if( ret == NULL ) {
+                free( cur );
+            }
+            return ret;
+        }
+    }
+    return bgn;
+}
+
+
 // Return a list of all infinite noise multipliers found.
-devlist_node listUSBDevices(char **message) {
+infnoise_devlist_node_t* listUSBDevices(char **message) {
     struct ftdi_context ftdic;
-    ftdi_init(&ftdic);
+    if(ftdi_init(&ftdic) < 0) {
+        *message = "Failed to init";
+        return NULL;
+    }
 
+    infnoise_devlist_node_t* retlist = NULL;
     struct ftdi_device_list *devlist = NULL;
-
+    if (ftdi_usb_find_all(&ftdic, &devlist, INFNOISE_VENDOR_ID, INFNOISE_PRODUCT_ID) < 0) {
-    // search devices
-    int rc = ftdi_usb_find_all(&ftdic, &devlist, INFNOISE_VENDOR_ID, INFNOISE_PRODUCT_ID);
-    if (rc < 0) {
         if (!isSuperUser()) {
             *message = "Can't find Infinite Noise Multiplier.  Try running as super user?";
         } else {
             *message = "Can't find Infinite Noise Multiplier.";
         }
-        return NULL;
+    }
+    else {
+        retlist = inf_get_devstrings(&ftdic, devlist, message, NULL, NULL);
+        ftdi_list_free2(devlist);
     }
 
-    devlist_node return_list = malloc(sizeof(struct infnoise_devlist_node));
+    ftdi_deinit(&ftdic);
-    devlist_node current_entry = return_list;
+    return retlist;
-    int i = 0;
-    struct ftdi_device_list *curdev = NULL;
-    for (curdev = devlist; curdev != NULL; curdev = curdev->next, i++) {
-        rc = ftdi_usb_get_strings(&ftdic, curdev->dev,
-                                  current_entry->manufacturer, sizeof(current_entry->manufacturer),
-                                  current_entry->description, sizeof(current_entry->description),
-                                  current_entry->serial, sizeof(current_entry->serial));
-        if (rc < 0) {
-            if (!isSuperUser()) {
-                *message = "Can't find Infinite Noise Multiplier. Try running as super user?";
-            } else {
-                sprintf(*message, "ftdi_usb_get_strings failed: %d (%s)", rc, ftdi_get_error_string(&ftdic));
-            }
-            return NULL;
-        }
-        current_entry->id = i;
-        if (curdev->next) {
-            current_entry->next = malloc(sizeof(struct infnoise_devlist_node));
-            current_entry = current_entry->next;
-        } else {
-            current_entry->next = NULL;
-        }
-    }
-    ftdi_list_free2(devlist);
-    return return_list;
 }
 
 // Initialize the Infinite Noise Multiplier USB interface.

software/libinfnoise.h

@@ -25,16 +25,14 @@ struct infnoise_context {
     uint32_t bytesWritten;
 };
 
-struct infnoise_devlist_node {
+typedef struct _infnoise_devlist_node_t infnoise_devlist_node_t;
-    uint8_t id;
+struct _infnoise_devlist_node_t {
     char manufacturer[128];
     char description[128];
     char serial[128];
-    struct infnoise_devlist_node *next;
+    infnoise_devlist_node_t *next;
 };
 
-typedef struct infnoise_devlist_node *devlist_node;
-
 /*
  * returns a struct of infnoise_devlist_node listing all connected FTDI FT240 devices by their USB descriptors
  *
@@ -43,7 +41,7 @@ typedef struct infnoise_devlist_node *devlist_node;
  *
  *  returns: NULL when none found or infnoise_devlist_node
  */
-devlist_node listUSBDevices(char **message);
+infnoise_devlist_node_t* listUSBDevices(char **message);
 
 /*
  * initialize the Infinite Noise TRNG - must be called once before readData() works