Added blocksize funcs, made funcs static

src/base32.c

@@ -21,18 +21,29 @@
 #include "encoding.h"
 #include "base32.h"
 
+#define BLKSIZE_RAW 5
+#define BLKSIZE_ENC 8
+
 static const char cb32[] = 
-	"abcdefghijklmnopqrstuvwxyz0123456789";
+	"abcdefghijklmnopqrstuvwxyz012345";
 static unsigned char rev32[128];
 static int reverse_init = 0;
 
+static int base32_decode(void *, size_t *, const char *, size_t);
+static int base32_encode(char *, size_t *, const void *, size_t);
+static int base32_handles_dots();
+static int base32_blksize_raw();
+static int base32_blksize_enc();
+
 static struct encoder base32_encoder =
 {
 	"Base32",
 	base32_encode,
 	base32_decode,
 	base32_handles_dots,
-	base32_handles_dots
+	base32_handles_dots,
+	base32_blksize_raw,
+	base32_blksize_enc
 };
 
 struct encoder
@@ -41,18 +52,29 @@ struct encoder
 	return &base32_encoder;
 }
 
-int 
+static int 
 base32_handles_dots()
 {
 	return 0;
 }
 
-int 
+static int 
+base32_blksize_raw()
+{
+	return BLKSIZE_RAW;
+}
+
+static int 
+base32_blksize_enc()
+{
+	return BLKSIZE_ENC;
+}
+
+static int 
 base32_encode(char *buf, size_t *buflen, const void *data, size_t size)
 {
 	size_t newsize;
 	size_t maxsize;
-	unsigned char *s;
 	unsigned char *p;
 	unsigned char *q;
 	int i;
@@ -60,18 +82,18 @@ base32_encode(char *buf, size_t *buflen, const void *data, size_t size)
 	memset(buf, 0, *buflen);
 
 	/* how many chars can we encode within the buf */
-	maxsize = 5 * (*buflen / 8 - 1) - 1;
+	maxsize = BLKSIZE_RAW * (*buflen / BLKSIZE_ENC - 1) - 1;
 	/* how big will the encoded data be */
-	newsize = 8 * (size / 5 + 1) + 1;
+	newsize = BLKSIZE_ENC * (size / BLKSIZE_RAW + 1) + 1;
 	/* if the buffer is too small, eat some of the data */
 	if (*buflen < newsize) {
 		size = maxsize;
 	}
 
-	p = s = (unsigned char *) buf;
+	p = (unsigned char *) buf;
 	q = (unsigned char *)data;
 
-	for(i=0;i<size;i+=5) {
+	for(i=0;i<size;i+=BLKSIZE_RAW) {
 		p[0] = cb32[((q[0] & 0xf8) >> 3)];
 		p[1] = cb32[(((q[0] & 0x07) << 2) | ((q[1] & 0xc0) >> 6))];
 		p[2] = (i+1 < size) ? cb32[((q[1] & 0x3e) >> 1)] : '\0';
@@ -81,8 +103,8 @@ base32_encode(char *buf, size_t *buflen, const void *data, size_t size)
 		p[6] = (i+3 < size) ? cb32[((q[3] & 0x03) << 3) | ((q[4] & 0xe0) >> 5)] : '\0';
 		p[7] = (i+4 < size) ? cb32[((q[4] & 0x1f))] : '\0';
 		
-		q += 5;
+		q += BLKSIZE_RAW;
-		p += 8;
+		p += BLKSIZE_ENC;
 	}	
 	*p = 0;
 
@@ -133,7 +155,7 @@ decode_token(const unsigned char *t, unsigned char *data, size_t len)
 	return 5;
 }
 
-int
+static int
 base32_decode(void *buf, size_t *buflen, const char *str, size_t slen)
 {
 	unsigned char *q;
@@ -153,21 +175,21 @@ base32_decode(void *buf, size_t *buflen, const char *str, size_t slen)
 	}
 	
 	/* chars needed to decode slen */
-	newsize = 5 * (slen / 8 + 1) + 1;
+	newsize = BLKSIZE_RAW * (slen / BLKSIZE_ENC + 1) + 1;
 	/* encoded chars that fit in buf */
-	maxsize = 8 * (*buflen / 5 + 1) + 1;
+	maxsize = BLKSIZE_ENC * (*buflen / BLKSIZE_RAW + 1) + 1;
 	/* if the buffer is too small, eat some of the data */
 	if (*buflen < newsize) {
 		slen = maxsize;
 	}
 
 	q = buf;
-	for (p = str; *p && strchr(cb32, *p); p += 8) {
+	for (p = str; *p && strchr(cb32, *p); p += BLKSIZE_ENC) {
 		len = decode_token((unsigned char *) p, (unsigned char *) q, slen);	
 		q += len;
-		slen -= 8;
+		slen -= BLKSIZE_ENC;
 		
-		if (len < 5)
+		if (len < BLKSIZE_RAW)
 			break;
 	}
 	*q = '\0';

src/base32.h

@@ -18,8 +18,5 @@
 #define __BASE32_H__
 
 struct encoder *get_base32_encoder(void);
-int base32_handles_dots();
-int base32_encode(char *, size_t *, const void *, size_t);
-int base32_decode(void *, size_t *, const char *, size_t);
 
 #endif

src/base64.c

@@ -22,11 +22,20 @@
 #include "common.h"
 #include "base64.h"
 
+#define BLKSIZE_RAW 3
+#define BLKSIZE_ENC 4
+
 static const char cb64[] = 
 	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789+";
 static unsigned char rev64[128];
 static int reverse_init = 0;
 
+static int base64_encode(char *, size_t *, const void *, size_t);
+static int base64_decode(void *, size_t *, const char *, size_t);
+static int base64_handles_dots();
+static int base64_blksize_raw();
+static int base64_blksize_enc();
+
 #define REV64(x) rev64[(int) (x)]
 
 static struct encoder base64_encoder =
@@ -35,7 +44,9 @@ static struct encoder base64_encoder =
 	base64_encode,
 	base64_decode,
 	base64_handles_dots,
-	base64_handles_dots
+	base64_handles_dots,
+	base64_blksize_raw,
+	base64_blksize_enc
 };
 
 struct encoder
@@ -44,13 +55,25 @@ struct encoder
 	return &base64_encoder;
 }
 
-int 
+static int 
 base64_handles_dots()
 {
 	return 0;
 }
 
-int 
+static int 
+base64_blksize_raw()
+{
+	return BLKSIZE_RAW;
+}
+
+static int 
+base64_blksize_enc()
+{
+	return BLKSIZE_ENC;
+}
+
+static int 
 base64_encode(char *buf, size_t *buflen, const void *data, size_t size)
 {
 	size_t newsize;
@@ -72,9 +95,9 @@ base64_encode(char *buf, size_t *buflen, const void *data, size_t size)
 	}
 
 	/* how many chars can we encode within the buf */
-	maxsize = 3 * (*buflen / 4 - 1) - 1;
+	maxsize = BLKSIZE_RAW * (*buflen / BLKSIZE_ENC - 1) - 1;
 	/* how big will the encoded data be */
-	newsize = 4 * (size / 3 + 1) + 1;
+	newsize = BLKSIZE_ENC * (size / BLKSIZE_RAW + 1) + 1;
 	/* if the buffer is too small, eat some of the data */
 	if (*buflen < newsize) {
 		size = maxsize;
@@ -83,14 +106,14 @@ base64_encode(char *buf, size_t *buflen, const void *data, size_t size)
 	p = s = (unsigned char *) buf;
 	q = (unsigned char *)data;
 
-	for(i=0;i<size;i+=3) {
+	for(i=0;i<size;i+=BLKSIZE_RAW) {
 		p[0] = cb64[((q[0] & 0xfc) >> 2)];
 		p[1] = cb64[(((q[0] & 0x03) << 4) | ((q[1] & 0xf0) >> 4))];
 		p[2] = (i+1 < size) ? cb64[((q[1] & 0x0f) << 2 ) | ((q[2] & 0xc0) >> 6)] : '\0';
 		p[3] = (i+2 < size) ? cb64[(q[2] & 0x3f)] : '\0';
 		
-		q += 3;
+		q += BLKSIZE_RAW;
-		p += 4;
+		p += BLKSIZE_ENC;
 	}	
 	*p = 0;
 
@@ -126,7 +149,7 @@ decode_token(const unsigned char *t, unsigned char *data, size_t len)
 	return 3;
 }
 
-int
+static int
 base64_decode(void *buf, size_t *buflen, const char *str, size_t slen)
 {
 	unsigned char *q;
@@ -134,7 +157,7 @@ base64_decode(void *buf, size_t *buflen, const char *str, size_t slen)
 	size_t maxsize;
 	const char *p;
 	unsigned char c;
-	unsigned char block[4];
+	unsigned char block[BLKSIZE_ENC];
 	int len;
 	int i;
 
@@ -147,9 +170,9 @@ base64_decode(void *buf, size_t *buflen, const char *str, size_t slen)
 	}
 	
 	/* chars needed to decode slen */
-	newsize = 3 * (slen / 4 + 1) + 1;
+	newsize = BLKSIZE_RAW * (slen / BLKSIZE_ENC + 1) + 1;
 	/* encoded chars that fit in buf */
-	maxsize = 4 * (*buflen / 3 + 1) + 1;
+	maxsize = BLKSIZE_ENC * (*buflen / BLKSIZE_RAW + 1) + 1;
 	/* if the buffer is too small, eat some of the data */
 	if (*buflen < newsize) {
 		slen = maxsize;
@@ -157,16 +180,16 @@ base64_decode(void *buf, size_t *buflen, const char *str, size_t slen)
 	
 
 	q = buf;
-	for (p = str; *p; p += 4) {
+	for (p = str; *p; p += BLKSIZE_ENC) {
 		/* since the str is const, we unescape in another buf */
-		for (i = 0; i < 4; i++) {
+		for (i = 0; i < BLKSIZE_ENC; i++) {
 			block[i] = p[i];
 		}
 		len = decode_token(block, (unsigned char *) q, slen);	
 		q += len;
-		slen -= 4;
+		slen -= BLKSIZE_ENC;
 		
-		if (len < 3)
+		if (len < BLKSIZE_RAW)
 			break;
 	}
 	*q = '\0';

src/base64.h

@@ -18,8 +18,5 @@
 #define __BASE64_H__
 
 struct encoder *get_base64_encoder(void);
-int base64_handles_dots();
-int base64_encode(char *, size_t *, const void *, size_t);
-int base64_decode(void *, size_t *, const char *, size_t);
 
 #endif

src/encoding.h

@@ -23,6 +23,8 @@ struct encoder {
 	int (*decode) (void *, size_t *, const char *, size_t);
 	int (*places_dots) (void);
 	int (*eats_dots) (void);
+	int (*blocksize_raw)(void);
+	int (*blocksize_encoded)(void);
 };
 
 int unpack_data(char *, size_t, char *, size_t, struct encoder *);