Index: trunk/Nebulous/nebclient/src/nebclient.c
===================================================================
--- trunk/Nebulous/nebclient/src/nebclient.c	(revision 24939)
+++ trunk/Nebulous/nebclient/src/nebclient.c	(revision 24997)
@@ -51,9 +51,8 @@
 static char *nullstrncpy(char *dest, const char *src, size_t n);
 
+
 nebServer *nebServerAlloc(const char *endpoint)
 {
-    nebServer       *server;
-
-    server          = xmalloc(sizeof(nebServer));
+    nebServer *server = xmalloc(sizeof(nebServer));
 
     if (endpoint) {
@@ -77,4 +76,5 @@
 }
 
+
 void nebServerFree(nebServer *server)
 {
@@ -92,17 +92,16 @@
 }
 
+
 char *nebCreate(nebServer *server, const char *key, const char *volume, char **URI)
 {
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return NULL;
+    }
+
     struct ns1__create_USCOREobjectResponse response;
-    char            *filename;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return NULL;
-    }
-
     if (soap_call_ns1__create_USCOREobject(server->soap, server->endpoint, NULL,
             (char *)key, (char *)volume, (char **)&response) != SOAP_OK) {
@@ -117,6 +116,9 @@
     }
 
+    char *filename;
     if (!nebParseURI(server, (char *)response.result, &filename)) {
         nebSetErr(server, "can not parse URI");
+        nebFree(filename);
+
         return NULL;
     }
@@ -131,20 +133,21 @@
 }
 
+
 int nebOpenCreate(nebServer *server, const char *key, const char *volume, char **URI)
 {
-    char            *filename;
-    int             file;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return -1;
-    }
-
-    filename = nebCreate(server, key, volume, URI);
-
-    file = open(filename, O_RDWR|O_TRUNC, 0660);
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return -1;
+    }
+
+    char *filename = nebCreate(server, key, volume, URI);
+    if (!filename) {
+        return -1;
+    }
+
+    int file = open(filename, O_RDWR|O_TRUNC, 0660);
     if (file == -1) {
         nebSetErr(server, "can not open %s: %s", filename, strerror(errno));
@@ -159,10 +162,7 @@
 }
 
+
 bool nebReplicate(nebServer *server, const char *key, const char *volume, char **URI)
 {
-    struct ns1__replicate_USCOREobjectResponse response;
-    char            *filename;
-    int             sourceFH, destFH;
-
     REQUIRE_SERVER;
 
@@ -177,8 +177,7 @@
     // we don't do this, it's possible that open will find & open the new
     // instance that we're in the process of creating
-    sourceFH = nebOpen(server, (char *)key, NEB_READ);
+    int sourceFH = nebOpen(server, (char *)key, NEB_READ);
     if (sourceFH == -1) {
         nebSetErr(server, "can not open key %s", key);
-        nebFree(filename);
 
         return false;
@@ -186,4 +185,5 @@
 
     // ask the server for a new instance attached to our key
+    struct ns1__replicate_USCOREobjectResponse response;
     if (soap_call_ns1__replicate_USCOREobject(server->soap, server->endpoint,
             NULL, (char *)key, (char *)volume, (char **)&response) != SOAP_OK) {
@@ -193,4 +193,5 @@
     }
 
+    char *filename = NULL;
     if (!nebParseURI(server, (char *)response.result, &filename)) {
         nebSetErr(server, "can not parse URI");
@@ -199,5 +200,5 @@
     }
 
-    destFH = open(filename, O_RDWR|O_TRUNC, 0660);
+    int destFH = open(filename, O_RDWR|O_TRUNC, 0660);
     if (destFH == -1) {
         nebSetErr(server, "can not open %s: %s\n", filename, strerror(errno));
@@ -234,19 +235,21 @@
 }
 
+
 bool nebCull(nebServer *server, const char *key)
 {
-    nebObjectInstances *locations;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return false;
-    }
-
-    locations = nebFindInstances(server, key, NULL);
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return false;
+    }
+
+    nebObjectInstances *locations = nebFindInstances(server, key, NULL);
     if (!locations || locations->n <= 1) {
         nebSetErr(server, "can not cull - not enough instances");
+        if (locations) {
+            nebObjectInstancesFree(locations);
+        }
 
         return false;
@@ -264,23 +267,21 @@
 }
 
+
 bool nebLock(nebServer *server, const char *key, nebRW flag)
 {
-    time_t          endtime;
-    char            *type;
-    int             response;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return false;
-    }
-
-    type = flag == NEB_READ ? "read" : "write";
-
-    endtime = time(NULL) + LOCK_TIMEOUT;
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return false;
+    }
+
+    char *type = flag == NEB_READ ? "read" : "write";
+
+    time_t endtime = time(NULL) + LOCK_TIMEOUT;
 
     while (time(NULL) < endtime) {
+        int response;
         if (soap_call_ns1__lock_USCOREobject(server->soap, server->endpoint,
             NULL, (char *)key, type, &response) != SOAP_OK) {
@@ -302,19 +303,18 @@
 }
 
+
 bool nebUnlock(nebServer *server, const char *key, nebRW flag)
 {
-    char            *type;
-    int             response;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return false;
-    }
-
-    type = flag == NEB_READ ? "read" : "write";
-
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return false;
+    }
+
+    char *type = flag == NEB_READ ? "read" : "write";
+
+    int response;
     if (soap_call_ns1__unlock_USCOREobject(server->soap, server->endpoint,
         NULL, (char *)key, type, &response) != SOAP_OK) {
@@ -466,17 +466,13 @@
 nebObjectInstances *nebFindInstances(nebServer *server, const char *key, const char *volume)
 {
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return NULL;
+    }
+
     struct ns1__find_USCOREinstancesResponse response;
-    int             resultElements = 0;
-    char            **resultArray;
-    nebObjectInstances *locations = NULL;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return NULL;
-    }
-
     // FIXME is this leaking memory when response goes out of scope?  the gsoap
     // manual seems to 'suggest' that this is temporary data that gets cleaed
@@ -488,11 +484,12 @@
     }
 
-    resultElements = response.result->__size;
-
+    int resultElements = response.result->__size;
+
+    nebObjectInstances *locations = NULL;
     if (resultElements) {
         locations = xmalloc(sizeof(nebObjectInstances));
         locations->n = resultElements;
         
-        resultArray    = response.result->__ptr;
+        char **resultArray = response.result->__ptr;
 
         locations->URI = xmalloc(sizeof(char*) * resultElements);
@@ -508,4 +505,5 @@
 }
 
+
 void nebObjectInstancesFree(nebObjectInstances *locations)
 {
@@ -521,9 +519,7 @@
 }
 
+
 char *nebFind(nebServer *server, const char *key)
 {
-    nebObjectInstances *locations;
-    char            *filename;
-
     REQUIRE_SERVER;
 
@@ -534,5 +530,5 @@
     }
     
-    locations = nebFindInstances(server, key, NULL);
+    nebObjectInstances *locations = nebFindInstances(server, key, NULL);
     if (!locations) {
         if (!strstr(nebErr(server), "no instances on storage volume")) {
@@ -548,4 +544,5 @@
     }
 
+    char *filename;
     if (!nebParseURI(server, locations->URI[0], &filename)) {
         nebSetErr(server, "can not parse URI");
@@ -560,19 +557,16 @@
 }
 
+
 int nebOpen(nebServer *server, const char *key, nebRW flag)
 {
-    nebObjectInstances *locations;
-    char            *filename;
-    int             fh;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return -1;
-    }
-
-    locations = nebFindInstances(server, key, NULL);
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return -1;
+    }
+
+    nebObjectInstances *locations = nebFindInstances(server, key, NULL);
     if (!locations) {
         nebSetErr(server, "no instances found");
@@ -581,4 +575,5 @@
     }
 
+    char *filename;
     if (!nebParseURI(server, locations->URI[0], &filename)) {
         nebSetErr(server, "can not parse URI");
@@ -588,4 +583,5 @@
     }
 
+    int fh = 0;
     if (flag == NEB_WRITE) {
         if (locations->n > 1) {
@@ -613,17 +609,16 @@
 }
 
+
 bool nebDelete(nebServer *server, const char *key)
 {
-    nebObjectInstances *locations;
-
-    REQUIRE_SERVER;
-
-    if (!key) {
-        nebSetErr(server, "parameter 'key' may not be NULL");
-
-        return false;
-    }
-
-    locations = nebFindInstances(server, key, "any");
+    REQUIRE_SERVER;
+
+    if (!key) {
+        nebSetErr(server, "parameter 'key' may not be NULL");
+
+        return false;
+    }
+
+    nebObjectInstances *locations = nebFindInstances(server, key, "any");
     if (!locations) {
         nebSetErr(server, "no instances found");
@@ -646,9 +641,7 @@
 }
 
+
 bool nebCopy(nebServer *server, const char *key, const char *newKey)
 {
-    int             sourceFH;
-    int             destFH;
-
     REQUIRE_SERVER;
 
@@ -665,5 +658,5 @@
     }
 
-    sourceFH = nebOpen(server, (char *)key, NEB_READ);
+    int sourceFH = nebOpen(server, (char *)key, NEB_READ);
     if (sourceFH < 0) {
         // propigate nebOpen() error
@@ -672,5 +665,5 @@
     }
 
-    destFH = nebOpenCreate(server, newKey, NULL, NULL);
+    int destFH = nebOpenCreate(server, newKey, NULL, NULL);
     if (destFH < 0) {
         // propigate nebCreate() error
@@ -696,4 +689,5 @@
 }
 
+
 bool nebMove(nebServer *server, const char *key, const char *newKey)
 {
@@ -723,8 +717,7 @@
 }
 
+
 bool nebSwap(nebServer *server, const char *key1, const char *key2)
 {
-    struct ns1__create_USCOREobjectResponse response;
-
     REQUIRE_SERVER;
 
@@ -741,4 +734,5 @@
     }
 
+    struct ns1__create_USCOREobjectResponse response;
     if (soap_call_ns1__swap_USCOREobjects(server->soap, server->endpoint,
             NULL, (char *)key1, (char *)key2, (char **)&response) != SOAP_OK) {
@@ -749,10 +743,7 @@
 }
 
+
 bool nebDeleteInstance(nebServer *server, const char *key, const char *URI)
 {
-    int             response;
-    char            *filename;
-    bool            status;
-
     REQUIRE_SERVER;
 
@@ -763,4 +754,5 @@
     }
 
+    char *filename;
     if (!nebParseURI(server, URI, &filename)) {
         nebSetErr(server, "can not parse URI");
@@ -769,4 +761,5 @@
     }
 
+    int response;
     if (soap_call_ns1__delete_USCOREinstance(server->soap, server->endpoint,
         NULL, (char *)key, (char *)URI, &response) != SOAP_OK) {
@@ -776,4 +769,5 @@
     }
 
+    bool status;
     if (response > 0) {
         status = nebNukeFile(server, filename);
@@ -787,11 +781,7 @@
 }
 
+
 nebObjectStat *nebStat(nebServer *server, const char *key)
 {
-    struct ns1__stat_USCOREobjectResponse response;
-    nebObjectStat   *stat;
-    int             resultElements = 0;
-    char            **resultArray = NULL;
-
     REQUIRE_SERVER;
 
@@ -802,9 +792,10 @@
     }
 
-    stat = xmalloc(sizeof(nebObjectStat));
+    nebObjectStat *stat = xmalloc(sizeof(nebObjectStat));
 
     // FIXME is this leaking memory when response goes out of scope?  the gsoap
     // manual seems to 'suggest' that this is temporary data that gets cleaed
     // up on the next soap function call
+    struct ns1__stat_USCOREobjectResponse response;
     if (soap_call_ns1__stat_USCOREobject(server->soap, server->endpoint,
             NULL, (char *)key, &response) != SOAP_OK) {
@@ -813,6 +804,6 @@
     }
 
-    resultElements = response.result->__size;
-    resultArray    = response.result->__ptr;
+    int resultElements = response.result->__size;
+    char **resultArray    = response.result->__ptr;
 
     if (resultElements != 8) {
@@ -833,4 +824,5 @@
 }
 
+
 void nebObjectStatFree(nebObjectStat *stat)
 {
@@ -895,4 +887,5 @@
     return response;
 }
+
 
 int nebThereCanBeOnlyOne(nebServer *server, const char *key, const char *volume)
@@ -936,4 +929,5 @@
         nebObjectInstancesFree(locations);
     } else {
+        nebObjectInstancesFree(locations);
         // nuke whatever
         nebObjectStat *stat = nebStat(server, key);
@@ -962,4 +956,5 @@
 }
 
+
 void nebFree(void *ptr) {
     xfree(ptr);
@@ -969,10 +964,6 @@
 static void p_nebSetErr(const char * filename, unsigned long lineno, const char *function, nebServer *server, const char *format, ...)
 {
-    va_list         args;
-    size_t          err_size;
-    char            err_location[ERRBUF_SIZE];
-    size_t          err_location_size; 
-
-    err_location_size = snprintf(err_location, ERRBUF_SIZE, "%s:%lu %s() - ",
+    char err_location[ERRBUF_SIZE];
+    size_t err_location_size = snprintf(err_location, ERRBUF_SIZE, "%s:%lu %s() - ",
             filename, lineno, function);
 
@@ -987,7 +978,8 @@
 
     while (1) {
+        va_list args;
         va_start(args, format);
         // append error string after error location info
-        err_size = vsnprintf(
+        size_t err_size = vsnprintf(
                 server->err_buf + err_location_size,
                 server->err_buf_size - err_location_size,
@@ -1013,27 +1005,22 @@
 }
 
+
 static void nebSetServerErr(nebServer *server)
 {
-    const char      **code;
-    const char      **string;
-
-    REQUIRE_SERVER;
-
-    code   = soap_faultcode(server->soap);
-    string = soap_faultstring(server->soap);
+    REQUIRE_SERVER;
+
+    const char **code   = soap_faultcode(server->soap);
+    const char **string = soap_faultstring(server->soap);
 
     nebSetErr(server, "%s - %s", *code, *string);
 }
+
 
 #if NEBCOPYFILE
 static off_t nebCopyFile(nebServer *server, const char *source, const char *dest)
 {
-    int             sourceFH;
-    int             destFH; 
-    off_t           bytesCopied;
-
-    REQUIRE_SERVER;
-
-    sourceFH = open(source, O_RDONLY);
+    REQUIRE_SERVER;
+
+    int sourceFH = open(source, O_RDONLY);
     if (sourceFH == -1) {
         nebSetErr(server, "can not open %s: %s", source, strerror(errno));
@@ -1042,5 +1029,5 @@
     }
 
-    destFH = open(dest, O_WRONLY|O_CREAT|O_CREAT, 0600);
+    int destFH = open(dest, O_WRONLY|O_CREAT|O_CREAT, 0600);
     if (destFH == -1) {
         nebSetErr(server, "can not open %s: %s", dest, strerror(errno));
@@ -1049,5 +1036,5 @@
     }
 
-    bytesCopied = nebCopyFilehandle(server, sourceFH, destFH);
+    off_t bytesCopied = nebCopyFilehandle(server, sourceFH, destFH);
     if (bytesCopied < 0) {
         return -1;
@@ -1069,4 +1056,5 @@
 }
 #endif
+
 
 static off_t nebCopyFilehandle(nebServer *server, int sourceFH, int destFH)
@@ -1121,4 +1109,5 @@
     return bytesTotal;
 }
+
 
 static size_t nebParseURI(nebServer *server, const char *URI, char **filename)
@@ -1181,4 +1170,5 @@
 }
 
+
 static bool nebNukeFile(nebServer *server, const char *filename)
 {
@@ -1199,4 +1189,5 @@
     return true;
 }
+
 
 static char *nullstrncpy(char *dest, const char *src, size_t n) {