Merge pull request #34 from rpmoore/master

Updating the xml parsing error reporting and adding additional logging statements

Author: robertgrimm

src/ds3.c

@@ -357,13 +357,17 @@ static char* _generate_date_string(void) {
     return date_string;
 }
 
-static char* _net_compute_signature(const ds3_creds* creds, http_verb verb, char* resource_name,
+static char* _net_compute_signature(const ds3_log* log, const ds3_creds* creds, http_verb verb, char* resource_name,
                              char* date, char* content_type, char* md5, char* amz_headers) {
     GHmac* hmac;
     gchar* signature;
     gsize bufSize = 256;
     guint8 buffer[256];
     unsigned char* signature_str = _generate_signature_str(verb, resource_name, date, content_type, md5, amz_headers);
+    char* escaped_str = g_strescape((char*) signature_str, NULL);
+
+    LOG(log, DEBUG, "signature string: %s", escaped_str);
+    g_free(escaped_str);
 
     hmac = g_hmac_new(G_CHECKSUM_SHA1, (unsigned char*) creds->secret_key->value, creds->secret_key->size);
     g_hmac_update(hmac, signature_str, -1);
@@ -467,12 +471,13 @@ static int ds3_curl_logger(CURL *handle, curl_infotype type, char* data, size_t
 }
 
 static ds3_error* _net_process_request(const ds3_client* client, const ds3_request* _request, void* read_user_struct, size_t (*read_handler_func)(void*, size_t, size_t, void*), void* write_user_struct, size_t (*write_handler_func)(void*, size_t, size_t, void*), GHashTable** return_headers) {
-    _init_curl();
-
     struct _ds3_request* request = (struct _ds3_request*) _request;
-    CURL* handle = curl_easy_init();
+    CURL* handle;
     CURLcode res;
 
+    _init_curl();
+    handle = curl_easy_init();
+
     if (handle) {
         char* url;
 
@@ -571,13 +576,12 @@ static ds3_error* _net_process_request(const ds3_client* client, const ds3_reque
 
         date = _generate_date_string();
         date_header = g_strconcat("Date: ", date, NULL);
-        signature = _net_compute_signature(client->creds, request->verb, request->path->value, date, "", "", "");
+        signature = _net_compute_signature(client->log, client->creds, request->verb, request->path->value, date, "", "", "");
         headers = NULL;
         auth_header = g_strconcat("Authorization: AWS ", client->creds->access_id->value, ":", signature, NULL);
 
         headers = curl_slist_append(headers, auth_header);
         headers = curl_slist_append(headers, date_header);
-
         headers = _append_headers(headers, request->headers);
 
         curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers);
@@ -610,9 +614,14 @@ static ds3_error* _net_process_request(const ds3_client* client, const ds3_reque
             error->error = g_new0(ds3_error_response, 1);
             error->error->status_code = response_data.status_code;
             error->error->status_message = ds3_str_init(response_data.status_message->value);
-            error->error->error_body = ds3_str_init_with_size((char*)response_data.body->data, response_data.body->len);
-
-            g_byte_array_free(response_data.body, TRUE);
+            if (response_data.body != NULL) {
+                error->error->error_body = ds3_str_init_with_size((char*)response_data.body->data, response_data.body->len);
+                g_byte_array_free(response_data.body, TRUE);
+            }
+            else {
+                LOG(client->log, ERROR, "The response body for the error is empty");
+                error->error->error_body = NULL;
+            }
             g_hash_table_destroy(response_headers);
             ds3_str_free(response_data.status_message);
             return error;
@@ -967,7 +976,7 @@ static ds3_bool xml_get_bool_from_attribute(const ds3_log* log, xmlDocPtr doc, s
     return result;
 }
 
-static void _parse_buckets(xmlDocPtr doc, xmlNodePtr buckets_node, ds3_get_service_response* response) {
+static void _parse_buckets(const ds3_log* log, xmlDocPtr doc, xmlNodePtr buckets_node, ds3_get_service_response* response) {
     xmlNodePtr data_ptr;
     xmlNodePtr curr;
     GArray* array = g_array_new(FALSE, TRUE, sizeof(ds3_bucket));
@@ -984,7 +993,7 @@ static void _parse_buckets(xmlDocPtr doc, xmlNodePtr buckets_node, ds3_get_servi
                 bucket.name = xml_get_string(doc, data_ptr);
             }
             else {
-                fprintf(stderr, "Unknown element: (%s)\n", data_ptr->name);
+                LOG(log, ERROR, "Unknown element: (%s)\n", data_ptr->name);
             }
         }
         g_array_append_val(array, bucket);
@@ -1060,15 +1069,15 @@ ds3_error* ds3_get_service(const ds3_client* client, const ds3_request* request,
     for(child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) {
         if(element_equal(child_node, "Buckets") == true) {
             //process buckets here
-            _parse_buckets(doc, child_node, response);
+            _parse_buckets(client->log, doc, child_node, response);
         }
         else if(element_equal(child_node, "Owner") == true) {
             //process owner here
             ds3_owner * owner = _parse_owner(doc, child_node);
             response->owner = owner;
         }
         else {
-            fprintf(stderr, "Unknown xml element: (%s)\b", child_node->name);
+            LOG(client->log, ERROR, "Unknown xml element: (%s)\b", child_node->name);
         }
     }
 
@@ -1129,21 +1138,21 @@ static ds3_object _parse_object(xmlDocPtr doc, xmlNodePtr contents_node) {
     return object;
 }
 
-static ds3_str* _parse_common_prefixes(xmlDocPtr doc, xmlNodePtr contents_node) {
+static ds3_str* _parse_common_prefixes(const ds3_log* log, xmlDocPtr doc, xmlNodePtr contents_node) {
     xmlNodePtr child_node;
     ds3_str* prefix = NULL;
 
     for(child_node = contents_node->xmlChildrenNode; child_node != NULL; child_node = child_node->next) {
         if(element_equal(child_node, "Prefix") == true) {
             if(prefix) {
-                fprintf(stderr, "More than one Prefix found in CommonPrefixes\n");
+                LOG(log, WARN, "More than one Prefix found in CommonPrefixes\n");
             }
             else {
                 prefix = xml_get_string(doc, child_node);
             }
         }
         else {
-            fprintf(stderr, "Unknown xml element: %s\n", child_node->name);
+            LOG(log, ERROR, "Unknown xml element: %s\n", child_node->name);
         }
     }
 
@@ -1260,11 +1269,11 @@ ds3_error* ds3_get_bucket(const ds3_client* client, const ds3_request* request,
             xmlFree(text);
         }
         else if(element_equal(child_node, "CommonPrefixes") == true) {
-            ds3_str* prefix = _parse_common_prefixes(doc, child_node);
+            ds3_str* prefix = _parse_common_prefixes(client->log, doc, child_node);
             g_array_append_val(common_prefix_array, prefix);
         }
         else {
-            fprintf(stderr, "Unknown element: (%s)\n", child_node->name);
+            LOG(client->log, ERROR, "Unknown element: (%s)\n", child_node->name);
         }
     }
 
@@ -1327,12 +1336,12 @@ static ds3_bulk_object _parse_bulk_object(const ds3_log* log, xmlDocPtr doc, xml
             response.offset = xml_get_uint64_from_attribute(doc, attribute);
         }
         else {
-            fprintf(stderr, "Unknown attribute: (%s)\n", attribute->name);
+            LOG(log, ERROR, "Unknown attribute: (%s)\n", attribute->name);
         }
     }
 
     for(child_node = object_node->xmlChildrenNode; child_node != NULL; child_node = child_node->next) {
-        fprintf(stderr, "Unknown element: (%s)\n", child_node->name);
+        LOG(log, ERROR, "Unknown element: (%s)\n", child_node->name);
     }
 
     return response;
@@ -1367,7 +1376,7 @@ static ds3_bulk_object_list* _parse_bulk_objects(const ds3_log* log, xmlDocPtr d
             response->chunk_number = xml_get_uint64_from_attribute(doc, attribute);
         }
         else {
-            fprintf(stderr, "Unknown attribute: (%s)\n", attribute->name);
+            LOG(log, ERROR, "Unknown attribute: (%s)\n", attribute->name);
         }
 
     }
@@ -1378,7 +1387,7 @@ static ds3_bulk_object_list* _parse_bulk_objects(const ds3_log* log, xmlDocPtr d
             g_array_append_val(object_array, object);
         }
         else {
-            fprintf(stderr, "Unknown element: (%s)\n", child_node->name);
+            LOG(log, ERROR, "Unknown element: (%s)\n", child_node->name);
         }
     }
 
@@ -1388,7 +1397,7 @@ static ds3_bulk_object_list* _parse_bulk_objects(const ds3_log* log, xmlDocPtr d
     return response;
 }
 
-static ds3_job_priority _match_priority(const xmlChar* priority_str) {
+static ds3_job_priority _match_priority(const ds3_log* log, const xmlChar* priority_str) {
     if (xmlStrcmp(priority_str, (const xmlChar*) "CRITICAL") == 0) {
         return CRITICAL;
     }
@@ -1411,51 +1420,51 @@ static ds3_job_priority _match_priority(const xmlChar* priority_str) {
         return MINIMIZED_DUE_TO_TOO_MANY_RETRIES;
     }
     else {
-        fprintf(stderr, "ERROR: Unknown priority type of '%s'.  Returning LOW to be safe.\n", priority_str);
+        LOG(log, ERROR, "ERROR: Unknown priority type of '%s'.  Returning LOW to be safe.\n", priority_str);
         return LOW;
     }
 }
 
-static ds3_job_request_type _match_request_type(const xmlChar* request_type) {
+static ds3_job_request_type _match_request_type(const ds3_log* log, const xmlChar* request_type) {
     if (xmlStrcmp(request_type, (const xmlChar*) "PUT") == 0) {
         return PUT;
     }
     else if (xmlStrcmp(request_type, (const xmlChar*) "GET") == 0) {
         return GET;
     }
     else {
-        fprintf(stderr, "ERROR: Unknown request type of '%s'.  Returning GET for safety.\n", request_type);
+        LOG(log, ERROR, "ERROR: Unknown request type of '%s'.  Returning GET for safety.\n", request_type);
         return GET;
     }
 }
 
-static ds3_write_optimization _match_write_optimization(const xmlChar* text) {
+static ds3_write_optimization _match_write_optimization(const ds3_log* log, const xmlChar* text) {
     if (xmlStrcmp(text, (const xmlChar*) "CAPACITY") == 0) {
         return CAPACITY;
     }
     else if (xmlStrcmp(text, (const xmlChar*) "PERFORMANCE") == 0) {
         return PERFORMANCE;
     }
     else {
-        fprintf(stderr, "ERROR: Unknown write optimization of '%s'.  Returning CAPACITY for safety.\n", text);
+        LOG(log, ERROR, "ERROR: Unknown write optimization of '%s'.  Returning CAPACITY for safety.\n", text);
         return CAPACITY;
     }
 }
 
-static ds3_chunk_ordering _match_chunk_order(const xmlChar* text) {
+static ds3_chunk_ordering _match_chunk_order(const ds3_log* log, const xmlChar* text) {
     if (xmlStrcmp(text, (const xmlChar*) "IN_ORDER") == 0) {
         return IN_ORDER;
     }
     else if (xmlStrcmp(text, (const xmlChar*) "NONE") == 0) {
         return NONE;
     }
     else {
-        fprintf(stderr, "ERROR: Unknown chunk processing order guaruntee value of '%s'.  Returning IN_ORDER for safety.\n", text);
+        LOG(log, ERROR, "ERROR: Unknown chunk processing order guaruntee value of '%s'.  Returning IN_ORDER for safety.\n", text);
         return NONE;
     }
 }
 
-static ds3_job_status _match_job_status(const xmlChar* text) {
+static ds3_job_status _match_job_status(const ds3_log* log, const xmlChar* text) {
     if(xmlStrcmp(text, (const xmlChar*) "IN_PROGRESS") == 0) {
         return IN_PROGRESS;
     }
@@ -1466,7 +1475,7 @@ static ds3_job_status _match_job_status(const xmlChar* text) {
         return CANCELED;
     }
     else {
-        fprintf(stderr, "ERROR: Unknown job status value of '%s'.  Returning IN_PROGRESS for safety.\n", text);
+        LOG(log, ERROR, "ERROR: Unknown job status value of '%s'.  Returning IN_PROGRESS for safety.\n", text);
         return IN_PROGRESS;
     }
 }
@@ -1547,39 +1556,39 @@ static ds3_error* _parse_master_object_list(const ds3_log* log, xmlDocPtr doc, d
             if(text == NULL) {
                 continue;
             }
-            response->priority = _match_priority(text);
+            response->priority = _match_priority(log, text);
             xmlFree(text);
         }
         else if(attribute_equal(attribute, "RequestType") == true) {
             text = xmlNodeListGetString(doc, attribute->children, 1);
             if(text == NULL) {
                 continue;
             }
-            response->request_type = _match_request_type(text);
+            response->request_type = _match_request_type(log, text);
             xmlFree(text);
         }
         else if(attribute_equal(attribute, "WriteOptimization") == true) {
             text = xmlNodeListGetString(doc, attribute->children, 1);
             if(text == NULL) {
                 continue;
             }
-            response->write_optimization = _match_write_optimization(text);
+            response->write_optimization = _match_write_optimization(log, text);
             xmlFree(text);
         }
         else if(attribute_equal(attribute, "ChunkClientProcessingOrderGuarantee") == true) {
             text = xmlNodeListGetString(doc, attribute->children, 1);
             if(text == NULL) {
                 continue;
             }
-            response->chunk_order = _match_chunk_order(text);
+            response->chunk_order = _match_chunk_order(log, text);
             xmlFree(text);
         }
         else if(attribute_equal(attribute, "Status") == true) {
             text = xmlNodeListGetString(doc, attribute->children, 1);
             if(text == NULL) {
                 continue;
             }
-            response->status = _match_job_status(text);
+            response->status = _match_job_status(log, text);
             xmlFree(text);
         }
         else {
@@ -2076,7 +2085,6 @@ void ds3_free_service_response(ds3_get_service_response* response){
 void ds3_free_bulk_response(ds3_bulk_response* response) {
     int i;
     if(response == NULL) {
-        fprintf(stderr, "Bulk response was NULL\n");
         return;
     }
 
@@ -2112,7 +2120,6 @@ void ds3_free_bulk_response(ds3_bulk_response* response) {
 
 void ds3_free_owner(ds3_owner* owner) {
     if(owner == NULL) {
-        fprintf(stderr, "Owner was NULL\n");
         return;
     }
     if(owner->name != NULL) {

test/test.cpp

@@ -25,13 +25,14 @@ ds3_client* get_client() {
 
     ds3_error* error = ds3_create_client_from_env(&client);
 
-    ds3_client_register_logging(client, INFO, test_log, NULL);
-
     if (error != NULL) {
         fprintf(stderr, "Failed to construct ds3_client from enviornment variables: %s\n", error->message->value);
-        exit(1);
+        ds3_free_error(error);
+        BOOST_FAIL("Failed to setup client.");
     }
 
+    ds3_client_register_logging(client, INFO, test_log, NULL);
+
     return client;
 }