From 900a0e8df7267b3e25075e60a9e64c6cbd6ed562 Mon Sep 17 00:00:00 2001 From: Erik Ekman Date: Sat, 6 Dec 2008 15:31:28 +0000 Subject: [PATCH] Added blocksize funcs, made funcs static --- src/base32.c | 56 +++++++++++++++++++++++++++++++++++--------------- src/base32.h | 3 --- src/base64.c | 55 ++++++++++++++++++++++++++++++++++--------------- src/base64.h | 3 --- src/encoding.h | 2 ++ 5 files changed, 80 insertions(+), 39 deletions(-) diff --git a/src/base32.c b/src/base32.c index e65f5ba..9040c88 100644 --- a/src/base32.c +++ b/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> 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; - p += 8; + q += BLKSIZE_RAW; + 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'; diff --git a/src/base32.h b/src/base32.h index b784bd0..3eb764d 100644 --- a/src/base32.h +++ b/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 diff --git a/src/base64.c b/src/base64.c index 2a7b5c6..c8550f0 100644 --- a/src/base64.c +++ b/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> 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; - p += 4; + q += BLKSIZE_RAW; + 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'; diff --git a/src/base64.h b/src/base64.h index 7518a58..53d5f4e 100644 --- a/src/base64.h +++ b/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 diff --git a/src/encoding.h b/src/encoding.h index f6142c7..9e93eed 100644 --- a/src/encoding.h +++ b/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 *);