Return std::string from base64 encoding function

This is avoids manual memory allocations.  Also add helper to simplify
assertions.

src/common_auth.cpp

@@ -30,20 +30,11 @@
 std::string s3fs_get_content_md5(int fd)
 {
     md5_t md5;
-    char* base64;
-    std::string Signature;
-
     if(!s3fs_md5_fd(fd, 0, -1, &md5)){
+        // TODO: better return value?
         return std::string("");
     }
-    if(nullptr == (base64 = s3fs_base64(md5.data(), md5.size()))){
-        return std::string("");  // ENOMEM
-    }
-
-    Signature = base64;
-    delete[] base64;
-
-    return Signature;
+    return s3fs_base64(md5.data(), md5.size());
 }
 
 std::string s3fs_sha256_hex_fd(int fd, off_t start, off_t size)

src/curl.cpp

@@ -815,16 +815,8 @@ bool S3fsCurl::PushbackSseKeys(const std::string& input)
             return false;
         }
     } else {
-        char* pbase64_key;
-
-        if(nullptr != (pbase64_key = s3fs_base64(reinterpret_cast<const unsigned char*>(onekey.c_str()), onekey.length()))) {
-            raw_key = onekey;
-            base64_key = pbase64_key;
-            delete[] pbase64_key;
-        } else {
-            S3FS_PRN_ERR("Failed to convert base64 from SSE-C key %s", onekey.c_str());
-            return false;
-        }
+        base64_key = s3fs_base64(reinterpret_cast<const unsigned char*>(onekey.c_str()), onekey.length());
+        raw_key = onekey;
     }
 
     // make MD5
@@ -2767,16 +2759,9 @@ std::string S3fsCurl::CalcSignatureV2(const std::string& method, const std::stri
 
     s3fs_HMAC(key, key_len, sdata, sdata_len, &md, &md_len);
 
-    char* base64;
-    if(nullptr == (base64 = s3fs_base64(md, md_len))){
-        delete[] md;
-        return std::string("");  // ENOMEM
-    }
+    Signature = s3fs_base64(md, md_len);
     delete[] md;
 
-    Signature = base64;
-    delete[] base64;
-
     return Signature;
 }
 
@@ -4124,9 +4109,8 @@ int S3fsCurl::UploadMultipartPostSetup(const char* tpath, int part_num, const st
             return -EIO;
         }
         partdata.etag = s3fs_hex_lower(md5raw.data(), md5raw.size());
-        char* md5base64p = s3fs_base64(md5raw.data(), md5raw.size());
-        requestHeaders = curl_slist_sort_insert(requestHeaders, "Content-MD5", md5base64p);
-        delete[] md5base64p;
+        std::string md5base64 = s3fs_base64(md5raw.data(), md5raw.size());
+        requestHeaders = curl_slist_sort_insert(requestHeaders, "Content-MD5", md5base64.c_str());
     }
 
     // make request

src/s3fs.cpp

@@ -3636,16 +3636,9 @@ static bool get_xattr_posix_key_value(const char* path, std::string& xattrvalue,
     }
 
     // convert value by base64
-    char* base64val = s3fs_base64((iter->second)->pvalue, (iter->second)->length);
-    if(!base64val){
-        free_xattrs(xattrs);
-        return false;
-    }
+    xattrvalue = s3fs_base64(iter->second->pvalue, iter->second->length);
     free_xattrs(xattrs);
 
-    xattrvalue = base64val;
-    delete[] base64val;
-
     return true;
 }
 
@@ -3771,11 +3764,7 @@ static std::string raw_build_xattrs(const xattrs_t& xattrs)
         strxattrs += "\":\"";
 
         if(iter->second){
-            char* base64val = s3fs_base64((iter->second)->pvalue, (iter->second)->length);
-            if(base64val){
-                strxattrs += base64val;
-                delete[] base64val;
-            }
+            strxattrs += s3fs_base64(iter->second->pvalue, iter->second->length);
         }
         strxattrs += '\"';
     }

src/string_util.cpp

@@ -373,15 +373,12 @@ std::string s3fs_hex_upper(const unsigned char* input, size_t length)
     return s3fs_hex(input, length, "0123456789ABCDEF");
 }
 
-char* s3fs_base64(const unsigned char* input, size_t length)
+std::string s3fs_base64(const unsigned char* input, size_t length)
 {
     static const char base[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-    char* result;
 
-    if(!input || 0 == length){
-        return nullptr;
-    }
-    result = new char[((length + 3 - 1) / 3) * 4 + 1];
+    std::string result;
+    result.reserve(((length + 3 - 1) / 3) * 4 + 1);
 
     unsigned char parts[4];
     size_t rpos;
@@ -392,12 +389,11 @@ char* s3fs_base64(const unsigned char* input, size_t length)
         parts[2] = (rpos + 1) < length ? (((input[rpos + 1] & 0x0f) << 2) | ((((rpos + 2) < length ? input[rpos + 2] : 0x00) & 0xc0) >> 6)) : 0x40;
         parts[3] = (rpos + 2) < length ? (input[rpos + 2] & 0x3f) : 0x40;
 
-        result[wpos++] = base[parts[0]];
-        result[wpos++] = base[parts[1]];
-        result[wpos++] = base[parts[2]];
-        result[wpos++] = base[parts[3]];
+        result += base[parts[0]];
+        result += base[parts[1]];
+        result += base[parts[2]];
+        result += base[parts[3]];
     }
-    result[wpos] = '\0';
 
     return result;
 }

src/string_util.h

@@ -105,8 +105,8 @@ bool get_keyword_value(const std::string& target, const char* keyword, std::stri
 //
 std::string s3fs_hex_lower(const unsigned char* input, size_t length);
 std::string s3fs_hex_upper(const unsigned char* input, size_t length);
-// TODO: return std::string
-char* s3fs_base64(const unsigned char* input, size_t length);
+std::string s3fs_base64(const unsigned char* input, size_t length);
+// TODO: return std::unique_ptr
 unsigned char* s3fs_decode64(const char* input, size_t input_len, size_t* plength);
 
 //

src/test_util.h

@@ -76,6 +76,11 @@ void assert_strequals(const char *x, const char *y, const char *file, int line)
   }
 }
 
+void assert_strequals(const std::string &x, const std::string &y, const char *file, int line)
+{
+    return assert_strequals(x.c_str(), y.c_str(), file, line);
+}
+
 void assert_bufequals(const char *x, size_t len1, const char *y, size_t len2, const char *file, int line)
 {
     if(x == nullptr && y == nullptr){