[svn-upgrade] Integrating new upstream version, iodine (0.5.0)
[debian/iodine.git] / src / base32.c
index d42c5e97a5602a7ec1698b0307cf44e26cd0a937..af6a2147ac1fa5cf8a3141f7d1327089801483c0 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2007 Bjorn Andersson <flex@kryo.se>, Erik Ekman <yarrick@kryo.se>
+ * Copyright (c) 2006-2009 Bjorn Andersson <flex@kryo.se>, Erik Ekman <yarrick@kryo.se>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
 #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",
        base32_encode,
        base32_decode,
        base32_handles_dots,
-       base32_handles_dots
+       base32_handles_dots,
+       base32_blksize_raw,
+       base32_blksize_enc
 };
 
 struct encoder
@@ -41,18 +52,50 @@ 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;
+}
+
+int
+b32_5to8(int in)
+{
+       return cb32[in & 31];
+}
+
+int
+b32_8to5(int in)
+{
+       int i;
+       int c;
+       if (!reverse_init) {
+               for (i = 0; i < 32; i++) {
+                       c = cb32[i];
+                       rev32[(int) c] = i;
+               }
+               reverse_init = 1;
+       }
+       return rev32[in];
+}
+
+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 +103,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 +124,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 +176,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 +196,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';