CDRIVER-508 namespace b64_ functions

We really shouldn't be kicking around non-static b64_ functions.
Namespace them all and let's be done with it.

Author: hanumantmk

src/mongoc/mongoc-b64-private.h

@@ -26,19 +26,19 @@
 #include "mongoc-config.h"
 
 int
-b64_ntop (uint8_t const *src,
-          size_t         srclength,
-          char          *target,
-          size_t         targsize);
+mongoc_b64_ntop (uint8_t const *src,
+                 size_t         srclength,
+                 char          *target,
+                 size_t         targsize);
 
 void
-b64_initialize_rmap (void);
+mongoc_b64_initialize_rmap (void);
 
 #ifdef MONGOC_ENABLE_SSL
 int
-b64_pton (char const *src,
-          uint8_t    *target,
-          size_t      targsize);
+mongoc_b64_pton (char const *src,
+                 uint8_t    *target,
+                 size_t      targsize);
 #endif
 
 #endif /* MONGOC_B64_PRIVATE_H */

src/mongoc/mongoc-b64.c

@@ -111,10 +111,10 @@ static const char Pad64 = '=';
  */
 
 int
-b64_ntop (uint8_t const *src,
-          size_t         srclength,
-          char          *target,
-          size_t         targsize)
+mongoc_b64_ntop (uint8_t const *src,
+                 size_t         srclength,
+                 char          *target,
+                 size_t         targsize)
 {
    size_t datalength = 0;
    uint8_t input[3];
@@ -251,49 +251,49 @@ b64_ntop (uint8_t const *src,
    it returns the number of data bytes stored at the target, or -1 on error.
  */
 
-static int b64rmap_initialized = 0;
-static uint8_t b64rmap[256];
+static int mongoc_b64rmap_initialized = 0;
+static uint8_t mongoc_b64rmap[256];
 
-static const uint8_t b64rmap_special = 0xf0;
-static const uint8_t b64rmap_end = 0xfd;
-static const uint8_t b64rmap_space = 0xfe;
-static const uint8_t b64rmap_invalid = 0xff;
+static const uint8_t mongoc_b64rmap_special = 0xf0;
+static const uint8_t mongoc_b64rmap_end = 0xfd;
+static const uint8_t mongoc_b64rmap_space = 0xfe;
+static const uint8_t mongoc_b64rmap_invalid = 0xff;
 
 /**
  * Initializing the reverse map is not thread safe.
  * Which is fine for NSD. For now...
  **/
 void
-b64_initialize_rmap (void)
+mongoc_b64_initialize_rmap (void)
 {
 	int i;
 	unsigned char ch;
 
 	/* Null: end of string, stop parsing */
-	b64rmap[0] = b64rmap_end;
+	mongoc_b64rmap[0] = mongoc_b64rmap_end;
 
 	for (i = 1; i < 256; ++i) {
 		ch = (unsigned char)i;
 		/* Whitespaces */
 		if (isspace(ch))
-			b64rmap[i] = b64rmap_space;
+			mongoc_b64rmap[i] = mongoc_b64rmap_space;
 		/* Padding: stop parsing */
 		else if (ch == Pad64)
-			b64rmap[i] = b64rmap_end;
+			mongoc_b64rmap[i] = mongoc_b64rmap_end;
 		/* Non-base64 char */
 		else
-			b64rmap[i] = b64rmap_invalid;
+			mongoc_b64rmap[i] = mongoc_b64rmap_invalid;
 	}
 
 	/* Fill reverse mapping for base64 chars */
 	for (i = 0; Base64[i] != '\0'; ++i)
-		b64rmap[(uint8_t)Base64[i]] = i;
+		mongoc_b64rmap[(uint8_t)Base64[i]] = i;
 
-	b64rmap_initialized = 1;
+	mongoc_b64rmap_initialized = 1;
 }
 
 static int
-b64_pton_do(char const *src, uint8_t *target, size_t targsize)
+mongoc_b64_pton_do(char const *src, uint8_t *target, size_t targsize)
 {
 	int tarindex, state, ch;
 	uint8_t ofs;
@@ -304,14 +304,14 @@ b64_pton_do(char const *src, uint8_t *target, size_t targsize)
 	while (1)
 	{
 		ch = *src++;
-		ofs = b64rmap[ch];
+		ofs = mongoc_b64rmap[ch];
 
-		if (ofs >= b64rmap_special) {
+		if (ofs >= mongoc_b64rmap_special) {
 			/* Ignore whitespaces */
-			if (ofs == b64rmap_space)
+			if (ofs == mongoc_b64rmap_space)
 				continue;
 			/* End of base64 characters */
-			if (ofs == b64rmap_end)
+			if (ofs == mongoc_b64rmap_end)
 				break;
 			/* A non-base64 character. */
 			return (-1);
@@ -369,7 +369,7 @@ b64_pton_do(char const *src, uint8_t *target, size_t targsize)
 		case 2:		/* Valid, means one byte of info */
 			/* Skip any number of spaces. */
 			for ((void)NULL; ch != '\0'; ch = *src++)
-				if (b64rmap[ch] != b64rmap_space)
+				if (mongoc_b64rmap[ch] != mongoc_b64rmap_space)
 					break;
 			/* Make sure there is another trailing = sign. */
 			if (ch != Pad64)
@@ -384,7 +384,7 @@ b64_pton_do(char const *src, uint8_t *target, size_t targsize)
 			 * whitespace after it?
 			 */
 			for ((void)NULL; ch != '\0'; ch = *src++)
-				if (b64rmap[ch] != b64rmap_space)
+				if (mongoc_b64rmap[ch] != mongoc_b64rmap_space)
 					return (-1);
 
 			/*
@@ -412,7 +412,7 @@ b64_pton_do(char const *src, uint8_t *target, size_t targsize)
 
 
 static int
-b64_pton_len(char const *src)
+mongoc_b64_pton_len(char const *src)
 {
 	int tarindex, state, ch;
 	uint8_t ofs;
@@ -423,14 +423,14 @@ b64_pton_len(char const *src)
 	while (1)
 	{
 		ch = *src++;
-		ofs = b64rmap[ch];
+		ofs = mongoc_b64rmap[ch];
 
-		if (ofs >= b64rmap_special) {
+		if (ofs >= mongoc_b64rmap_special) {
 			/* Ignore whitespaces */
-			if (ofs == b64rmap_space)
+			if (ofs == mongoc_b64rmap_space)
 				continue;
 			/* End of base64 characters */
-			if (ofs == b64rmap_end)
+			if (ofs == mongoc_b64rmap_end)
 				break;
 			/* A non-base64 character. */
 			return (-1);
@@ -472,7 +472,7 @@ b64_pton_len(char const *src)
 		case 2:		/* Valid, means one byte of info */
 			/* Skip any number of spaces. */
 			for ((void)NULL; ch != '\0'; ch = *src++)
-				if (b64rmap[ch] != b64rmap_space)
+				if (mongoc_b64rmap[ch] != mongoc_b64rmap_space)
 					break;
 			/* Make sure there is another trailing = sign. */
 			if (ch != Pad64)
@@ -487,7 +487,7 @@ b64_pton_len(char const *src)
 			 * whitespace after it?
 			 */
 			for ((void)NULL; ch != '\0'; ch = *src++)
-				if (b64rmap[ch] != b64rmap_space)
+				if (mongoc_b64rmap[ch] != mongoc_b64rmap_space)
 					return (-1);
 
 		default:
@@ -507,15 +507,15 @@ b64_pton_len(char const *src)
 
 
 int
-b64_pton(char const *src, uint8_t *target, size_t targsize)
+mongoc_b64_pton(char const *src, uint8_t *target, size_t targsize)
 {
-	if (!b64rmap_initialized)
-		b64_initialize_rmap ();
+	if (!mongoc_b64rmap_initialized)
+		mongoc_b64_initialize_rmap ();
 
 	if (target)
-		return b64_pton_do (src, target, targsize);
+		return mongoc_b64_pton_do (src, target, targsize);
 	else
-		return b64_pton_len (src);
+		return mongoc_b64_pton_len (src);
 }
 
 #endif /* MONGOC_ENABLE_SSL */

src/mongoc/mongoc-cluster.c

@@ -1605,7 +1605,7 @@ _mongoc_cluster_auth_node_plain (mongoc_cluster_t      *cluster,
 
    str = bson_strdup_printf ("%c%s%c%s", '\0', username, '\0', password);
    len = strlen (username) + strlen (password) + 2;
-   buflen = b64_ntop ((const uint8_t *) str, len, buf, sizeof buf);
+   buflen = mongoc_b64_ntop ((const uint8_t *) str, len, buf, sizeof buf);
    bson_free (str);
 
    if (buflen == -1) {

src/mongoc/mongoc-scram.c

@@ -42,7 +42,7 @@
 void
 _mongoc_scram_startup()
 {
-   b64_initialize_rmap();
+   mongoc_b64_initialize_rmap();
 }
 
 
@@ -153,8 +153,8 @@ _mongoc_scram_start (mongoc_scram_t *scram,
    }
 
    scram->encoded_nonce_len =
-      b64_ntop (nonce, sizeof (nonce), scram->encoded_nonce,
-                sizeof (scram->encoded_nonce));
+      mongoc_b64_ntop (nonce, sizeof (nonce), scram->encoded_nonce,
+                       sizeof (scram->encoded_nonce));
 
    if (-1 == scram->encoded_nonce_len) {
       bson_set_error (error,
@@ -344,9 +344,9 @@ _mongoc_scram_generate_client_proof (mongoc_scram_t *scram,
       client_proof[i] = client_key[i] ^ client_signature[i];
    }
 
-   r = b64_ntop (client_proof, sizeof (client_proof),
-                 (char *)outbuf + *outbuflen,
-                 outbufmax - *outbuflen);
+   r = mongoc_b64_ntop (client_proof, sizeof (client_proof),
+                        (char *)outbuf + *outbuflen,
+                        outbufmax - *outbuflen);
 
    if (-1 == r) {
       return false;
@@ -534,7 +534,7 @@ _mongoc_scram_step2 (mongoc_scram_t *scram,
    }
 
    decoded_salt_len =
-      b64_pton ((char *)val_s, decoded_salt, sizeof (decoded_salt));
+      mongoc_b64_pton ((char *)val_s, decoded_salt, sizeof (decoded_salt));
 
    if (-1 == decoded_salt_len) {
       bson_set_error (error,
@@ -635,9 +635,9 @@ _mongoc_scram_verify_server_signature (mongoc_scram_t *scram,
          &hash_len);
 
    encoded_server_signature_len =
-      b64_ntop (server_signature, sizeof (server_signature),
-                encoded_server_signature,
-                sizeof (encoded_server_signature));
+      mongoc_b64_ntop (server_signature, sizeof (server_signature),
+                       encoded_server_signature,
+                       sizeof (encoded_server_signature));
 
    return (len == encoded_server_signature_len) &&
           (memcmp (verification, encoded_server_signature, len) == 0);