Index: /trunk/Nebulous/nebclient/src/nebclient.c
===================================================================
--- /trunk/Nebulous/nebclient/src/nebclient.c	(revision 4648)
+++ /trunk/Nebulous/nebclient/src/nebclient.c	(revision 4649)
@@ -4,5 +4,5 @@
  * Copyright (C) 2005  Joshua Hoblitt
  *
- * $Id: nebclient.c,v 1.31 2005-07-28 23:03:45 jhoblitt Exp $
+ * $Id: nebclient.c,v 1.32 2005-07-28 23:32:57 jhoblitt Exp $
  */
 
@@ -182,24 +182,20 @@
 bool nebCull(nebServer *server, const char *key)
 {
-    char            **locations;
-    int             instances;
-
-    instances = nebFindInstances(server, key, NULL, &locations);
-    if (instances < 2) {
+    nebObjectInstances *locations;
+
+    locations = nebFindInstances(server, key, NULL);
+    if (!locations) {
         nebSetErr(server, "can not cull - not enough instances");
-        if (instances) {
-            nebFree(locations);
-        }
-
-        return false;
-    }
-
-    if (!nebDeleteInstance(server, locations[0])) {
-        nebFree(locations);
-
-        return false;
-    }
-
-    nebFree(locations);
+
+        return false;
+    }
+
+    if (!nebDeleteInstance(server, locations->URI[0])) {
+        nebObjectInstancesFree(locations);
+
+        return false;
+    }
+
+    nebObjectInstancesFree(locations);
 
     return true;
@@ -259,11 +255,10 @@
 }
 
-int nebFindInstances(nebServer *server, const char *key, const char *volume, char ***locations)
+nebObjectInstances *nebFindInstances(nebServer *server, const char *key, const char *volume)
 {
     struct ns1__find_USCOREinstancesResponse response;
     int             resultElements = 0;
-    int             i;
     char            **resultArray;
-    char            **loc;
+    nebObjectInstances *locations = NULL;
 
     // FIXME is this leaking memory when response goes out of scope?  the gsoap
@@ -273,36 +268,45 @@
             NULL, (char *)key, (char *)volume, &response) != SOAP_OK) {
         nebSetServerErr(server);
-        return -1;
+        return NULL;
     }
 
     resultElements = response.result->__size;
 
+    if (resultElements) {
+        locations = xmalloc(sizeof(nebObjectInstances));
+        locations->n = resultElements;
+        
+        resultArray    = response.result->__ptr;
+
+        locations->URI = xmalloc(sizeof(char*) * resultElements);
+
+        for (int i = 0; i < resultElements; i++) {
+            locations->URI[i] = xmalloc(strlen(resultArray[i]) + 1);
+            strcpy(locations->URI[i], resultArray[i]);
+        }
+
+    }
+
+    return locations;
+}
+
+void nebObjectInstancesFree(nebObjectInstances *locations)
+{
     if (locations) {
-        if (resultElements) {
-            resultArray    = response.result->__ptr;
-
-            loc = xmalloc(sizeof(char*) * resultElements);
-
-            for (i = 0; i < resultElements; i++) {
-                loc[i] = xmalloc(strlen(resultArray[i]) + 1);
-
-                strcpy(loc[i], resultArray[i]);
-            }
-
-            *locations = loc;
-        } else {
-            *locations = NULL;
-        }
-    }
-
-    return resultElements;
+        for (int i = 0; i < locations->n; i++) {
+            nebFree(locations->URI[i]);
+        }
+
+        nebFree(locations);
+    }
 }
 
 char *nebFind(nebServer *server, const char *key)
 {
-    char            **locations;
+    nebObjectInstances *locations;
     char            *filename;
     
-    if (nebFindInstances(server, key, NULL, &locations) < 1) {
+    locations = nebFindInstances(server, key, NULL);
+    if (!locations) {
         nebSetErr(server, "no instances found");
 
@@ -310,12 +314,12 @@
     }
 
-    if (!nebParseURI(server, locations[0], &filename)) {
+    if (!nebParseURI(server, locations->URI[0], &filename)) {
         nebSetErr(server, "can not parse URI");
-        nebFree(locations);
+        nebObjectInstancesFree(locations);
 
         return NULL;
     }
 
-    nebFree(locations);
+    nebObjectInstancesFree(locations);
 
     return filename;
@@ -324,11 +328,11 @@
 int nebOpen(nebServer *server, const char *key, nebRW flag)
 {
-    char            **locations;
+    nebObjectInstances *locations;
     char            *filename;
     int             instances;
     int             fh;
 
-    instances = nebFindInstances(server, key, NULL, &locations);
-    if (instances < 1) {
+    locations = nebFindInstances(server, key, NULL);
+    if (!locations) {
         nebSetErr(server, "no instances found");
 
@@ -336,7 +340,7 @@
     }
 
-    if (!nebParseURI(server, locations[0], &filename)) {
+    if (!nebParseURI(server, locations->URI[0], &filename)) {
         nebSetErr(server, "can not parse URI");
-        nebFree(locations);
+        nebObjectInstancesFree(locations);
 
         return -1;
@@ -347,5 +351,5 @@
             nebSetErr(server, "write not allowed with multiple instances");
             nebFree(filename);
-            nebFree(locations);
+            nebObjectInstancesFree(locations);
 
             return -1;
@@ -360,10 +364,10 @@
     if (fh < 0) {
         nebSetErr(server, "open: %s", strerror(errno));
-        nebFree(locations);
-
-        return -1;
-    }
-
-    nebFree(locations);
+        nebObjectInstancesFree(locations);
+
+        return -1;
+    }
+
+    nebObjectInstancesFree(locations);
 
     return fh;
@@ -372,21 +376,17 @@
 bool nebDelete(nebServer *server, const char *key)
 {
-    char            **locations;
-    int             n;
-    int             i;
-
-    n = nebFindInstances(server, key, NULL, &locations);
-
-    if (n < 0) {
+    nebObjectInstances *locations;
+
+    locations = nebFindInstances(server, key, NULL);
+    if (!locations) {
         nebSetErr(server, "no instances found");
-        nebFree(locations);
-
-        return false;
-    }
-
-    for (i = 0; i < n; i++) {
-        if (!nebDeleteInstance(server, locations[i])) {
+
+        return false;
+    }
+
+    for (int i = 0; i < locations->n; i++) {
+        if (!nebDeleteInstance(server, locations->URI[i])) {
             nebSetErr(server, "can not delete instance");
-            nebFree(locations);
+            nebObjectInstancesFree(locations);
 
             return false;
@@ -394,5 +394,5 @@
     }
 
-    nebFree(locations);
+    nebObjectInstancesFree(locations);
 
     return true;
Index: /trunk/Nebulous/nebclient/src/nebclient.h
===================================================================
--- /trunk/Nebulous/nebclient/src/nebclient.h	(revision 4648)
+++ /trunk/Nebulous/nebclient/src/nebclient.h	(revision 4649)
@@ -4,5 +4,5 @@
  * Copyright (C) 2005  Joshua Hoblitt
  *
- * $Id: nebclient.h,v 1.23 2005-07-28 21:56:34 jhoblitt Exp $
+ * $Id: nebclient.h,v 1.24 2005-07-28 23:32:57 jhoblitt Exp $
  */
 
@@ -32,4 +32,9 @@
 } nebObjectStat;
 
+typedef struct {
+    unsigned int    n;
+    char            **URI;
+} nebObjectInstances;
+
 nebServer *nebServerAlloc(const char *endpoint);
 
@@ -46,5 +51,7 @@
 bool nebUnlock(nebServer *server, const char *key, nebRW flag);
 
-int nebFindInstances(nebServer *server, const char *key, const char *volume, char ***locations);
+nebObjectInstances *nebFindInstances(nebServer *server, const char *key, const char *volume);
+
+void nebObjectInstancesFree(nebObjectInstances *locations);
 
 char *nebFind(nebServer *server, const char *key);
Index: /trunk/Nebulous/nebclient/tests/tests.c
===================================================================
--- /trunk/Nebulous/nebclient/tests/tests.c	(revision 4648)
+++ /trunk/Nebulous/nebclient/tests/tests.c	(revision 4649)
@@ -61,11 +61,10 @@
 
     {
-        char        **locations = NULL;
-        int         n;
+        nebObjectInstances *locations = NULL;
 
-        n = nebFindInstances(server, key, NULL, &locations);
+        locations = nebFindInstances(server, key, NULL);
 
-        OK(n == 1, "find instances");
         OK(locations, "locations not NULL");
+        OK(locations->n == 1, "find instances");
     }