utils: cleanup Base64Encode

src/zm_ffmpeg_camera.cpp

@@ -273,7 +273,7 @@ int FfmpegCamera::OpenFfmpeg() {
 
   // Set transport method as specified by method field, rtpUni is default
   std::string protocol = mPath.substr(0, 4);
-  string_toupper(protocol);
+  StringToUpper(protocol);
   if ( protocol == "RTSP" ) {
     const std::string method = Method();
     if ( method == "rtpMulti" ) {

src/zm_remote_camera.cpp

@@ -83,7 +83,7 @@ void RemoteCamera::Initialise() {
   if ( authIndex != std::string::npos ) {
     auth = host.substr( 0, authIndex );
     host.erase( 0, authIndex+1 );
-    auth64 = base64Encode( auth );
+    auth64 = Base64Encode(auth);
 
     authIndex = auth.rfind( ':' );
     username = auth.substr(0,authIndex);

src/zm_rtsp.cpp

@@ -42,7 +42,7 @@ bool RtspThread::sendCommand(std::string message) {
   message += stringtf("CSeq: %d\r\n\r\n", ++mSeq);
   Debug(2, "Sending RTSP message: %s", message.c_str());
   if ( mMethod == RTP_RTSP_HTTP ) {
-    message = base64Encode(message);
+    message = Base64Encode(message);
     Debug(2, "Sending encoded RTSP message: %s", message.c_str());
     if ( mRtspSocket2.send(message.c_str(), message.size()) != (int)message.length() ) {
       Error("Unable to send message '%s': %s", message.c_str(), strerror(errno));

src/zm_rtsp_auth.cpp

@@ -98,7 +98,7 @@ std::string Authenticator::quote( const std::string &src ) {
 std::string Authenticator::getAuthHeader(std::string method, std::string uri) {
   std::string result = "Authorization: ";
   if ( fAuthMethod == AUTH_BASIC ) {
-    result += "Basic " + base64Encode(username() + ":" + password());
+    result += "Basic " + Base64Encode(username() + ":" + password());
   } else if ( fAuthMethod == AUTH_DIGEST ) {
     result += std::string("Digest ") + 
           "username=\"" + quote(username()) + "\", realm=\"" + quote(realm()) + "\", " +

src/zm_utils.cpp

@@ -21,7 +21,6 @@
 
 #include "zm_config.h"
 #include "zm_logger.h"
-#include <algorithm>
 #include <array>
 #include <cstring>
 #include <fcntl.h> /* Definition of AT_* constants */
@@ -121,36 +120,36 @@ std::string Join(const StringVector &values, const std::string &delim) {
   return ss.str();
 }
 
-const std::string base64Encode(const std::string &inString) {
+std::string Base64Encode(const std::string &str) {
-  static char base64_table[64] = { '\0' };
+  static char base64_table[64] = {'\0'};
 
-  if ( !base64_table[0] ) {
+  if (!base64_table[0]) {
     int i = 0;
-    for ( char c = 'A'; c <= 'Z'; c++ )
+    for (char c = 'A'; c <= 'Z'; c++)
       base64_table[i++] = c;
-    for ( char c = 'a'; c <= 'z'; c++ )
+    for (char c = 'a'; c <= 'z'; c++)
       base64_table[i++] = c;
-    for ( char c = '0'; c <= '9'; c++ )
+    for (char c = '0'; c <= '9'; c++)
       base64_table[i++] = c;
     base64_table[i++] = '+';
     base64_table[i++] = '/';
   }
 
   std::string outString;
-  outString.reserve(2 * inString.size());
+  outString.reserve(2 * str.size());
 
-  const char *inPtr = inString.c_str();
+  const char *inPtr = str.c_str();
-  while ( *inPtr ) {
+  while (*inPtr) {
     unsigned char selection = *inPtr >> 2;
     unsigned char remainder = (*inPtr++ & 0x03) << 4;
     outString += base64_table[selection];
 
-    if ( *inPtr ) {
+    if (*inPtr) {
       selection = remainder | (*inPtr >> 4);
       remainder = (*inPtr++ & 0x0f) << 2;
       outString += base64_table[selection];
 
-      if ( *inPtr ) {
+      if (*inPtr) {
         selection = remainder | (*inPtr >> 6);
         outString += base64_table[selection];
         selection = (*inPtr++ & 0x3f);
@@ -333,10 +332,6 @@ std::string UriDecode( const std::string &encoded ) {
   return retbuf;
 }
 
-void string_toupper( std::string& str) {
-  std::transform(str.begin(), str.end(), str.begin(), ::toupper);
-}
-
 void touch(const char *pathname) {
   int fd = open(pathname,
       O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK,

src/zm_utils.h

@@ -20,6 +20,7 @@
 #ifndef ZM_UTILS_H
 #define ZM_UTILS_H
 
+#include <algorithm>
 #include <chrono>
 #include <ctime>
 #include <map>
@@ -34,6 +35,7 @@ typedef std::vector<std::string> StringVector;
 std::string Trim(const std::string &str, const std::string &char_set);
 inline std::string TrimSpaces(const std::string &str) { return Trim(str, " \t"); }
 std::string ReplaceAll(std::string str, const std::string& old_value, const std::string& new_value);
+inline void StringToUpper(std::string &str) { std::transform(str.begin(), str.end(), str.begin(), ::toupper); }
 
 StringVector Split(const std::string &str, char delim);
 StringVector Split(const std::string &str, const std::string &delim, size_t limit = 0);
@@ -56,8 +58,7 @@ std::string stringtf(const std::string &format, Args... args) {
   return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
 }
 
-const std::string base64Encode( const std::string &inString );
+std::string Base64Encode(const std::string &str);
-void string_toupper(std::string& str);
 
 void* sse2_aligned_memcpy(void* dest, const void* src, size_t bytes);
 void timespec_diff(struct timespec *start, struct timespec *end, struct timespec *diff);

tests/zm_utils.cpp

@@ -140,14 +140,14 @@ TEST_CASE("Join") {
   REQUIRE(Join({"a", "b"}, "") == "ab");
 }
 
-TEST_CASE("base64Encode") {
+TEST_CASE("Base64Encode") {
-  REQUIRE(base64Encode("") == "");
+  REQUIRE(Base64Encode("") == "");
-  REQUIRE(base64Encode("f") == "Zg==");
+  REQUIRE(Base64Encode("f") == "Zg==");
-  REQUIRE(base64Encode("fo") == "Zm8=");
+  REQUIRE(Base64Encode("fo") == "Zm8=");
-  REQUIRE(base64Encode("foo") == "Zm9v");
+  REQUIRE(Base64Encode("foo") == "Zm9v");
-  REQUIRE(base64Encode("foob") == "Zm9vYg==");
+  REQUIRE(Base64Encode("foob") == "Zm9vYg==");
-  REQUIRE(base64Encode("fooba") == "Zm9vYmE=");
+  REQUIRE(Base64Encode("fooba") == "Zm9vYmE=");
-  REQUIRE(base64Encode("foobar") == "Zm9vYmFy");
+  REQUIRE(Base64Encode("foobar") == "Zm9vYmFy");
 }
 
 TEST_CASE("UriDecode") {