* tiny tool for message retrieval, first draft.

[citadel.git] / citadel / tools.c

diff --git a/citadel/tools.c b/citadel/tools.c
index 4e1129a731a72ca39e0a68af74b9f32f0d5622d8..b864642591c6cb205475f3e673129545ac81920b 100644 (file)
--- a/citadel/tools.c
+++ b/citadel/tools.c
@@ -33,7 +33,8 @@
 #define FALSE 0
 
 typedef unsigned char byte;          /* Byte type */
-static byte dtable[256];             /* base64 encode / decode table */
+static byte dtable[256] = "\0";              /* base64 decode table */
+static byte etable[256] = "\0";              /* base64 encode table */
 
 /* Month strings for date conversions */
 char *ascmonths[12] = {
@@ -127,6 +128,8 @@ long extract_token(char *dest, const char *source, int parmnum, char separator,
        if (s == NULL) {
                return(-1);
        }
+       
+       maxlen--;
 
        while (*s) {
                if (*s == separator) {
@@ -278,6 +281,41 @@ unsigned long extract_unsigned_long(const char *source, int parmnum)
 }
 
 
+
+void CtdlInitBase64Table(void)
+{
+       int i;
+       /*      Fill dtable with character encodings.  */
+       
+       /* Encoder Table */
+       for (i = 0; i < 26; i++) {
+               etable[i] = 'A' + i;
+               etable[26 + i] = 'a' + i;
+       }
+       for (i = 0; i < 10; i++) {
+               etable[52 + i] = '0' + i;
+       }
+       etable[62] = '+';
+       etable[63] = '/';
+       
+       /* Decoder Table */
+       for (i = 0; i < 255; i++) {
+               dtable[i] = 0x80;
+       }
+       for (i = 'A'; i <= 'Z'; i++) {
+               dtable[i] = 0 + (i - 'A');
+       }
+       for (i = 'a'; i <= 'z'; i++) {
+               dtable[i] = 26 + (i - 'a');
+       }
+       for (i = '0'; i <= '9'; i++) {
+               dtable[i] = 52 + (i - '0');
+       }
+       dtable['+'] = 62;
+       dtable['/'] = 63;
+       dtable['='] = 0;
+}
+
 /*
  * CtdlDecodeBase64() and CtdlEncodeBase64() are adaptations of code by
  * John Walker, found in full in the file "base64.c" included with this
@@ -291,18 +329,6 @@ void CtdlEncodeBase64(char *dest, const char *source, size_t sourcelen)
     int spos = 0;
     int dpos = 0;
 
-    /* Fill dtable with character encodings.  */
-
-    for (i = 0; i < 26; i++) {
-        dtable[i] = 'A' + i;
-        dtable[26 + i] = 'a' + i;
-    }
-    for (i = 0; i < 10; i++) {
-        dtable[52 + i] = '0' + i;
-    }
-    dtable[62] = '+';
-    dtable[63] = '/';
-
     while (!hiteof) {
        byte igroup[3], ogroup[4];
        int c, n;
@@ -317,10 +343,10 @@ void CtdlEncodeBase64(char *dest, const char *source, size_t sourcelen)
            igroup[n] = (byte) c;
        }
        if (n > 0) {
-           ogroup[0] = dtable[igroup[0] >> 2];
-           ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
-           ogroup[2] = dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
-           ogroup[3] = dtable[igroup[2] & 0x3F];
+           ogroup[0] = etable[igroup[0] >> 2];
+           ogroup[1] = etable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
+           ogroup[2] = etable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
+           ogroup[3] = etable[igroup[2] & 0x3F];
 
             /* Replace characters in output stream with "=" pad
               characters if fewer than three characters were
@@ -351,21 +377,6 @@ int CtdlDecodeBase64(char *dest, const char *source, size_t length)
     int dpos = 0;
     int spos = 0;
 
-    for (i = 0; i < 255; i++) {
-       dtable[i] = 0x80;
-    }
-    for (i = 'A'; i <= 'Z'; i++) {
-        dtable[i] = 0 + (i - 'A');
-    }
-    for (i = 'a'; i <= 'z'; i++) {
-        dtable[i] = 26 + (i - 'a');
-    }
-    for (i = '0'; i <= '9'; i++) {
-        dtable[i] = 52 + (i - '0');
-    }
-    dtable['+'] = 62;
-    dtable['/'] = 63;
-    dtable['='] = 0;
 
     /*CONSTANTCONDITION*/
     while (TRUE) {
@@ -405,6 +416,43 @@ int CtdlDecodeBase64(char *dest, const char *source, size_t length)
     }
 }
 
+/*
+ * Convert "quoted-printable" to binary.  Returns number of bytes decoded.
+ * according to RFC2045 section 6.7
+ */
+int CtdlDecodeQuotedPrintable(char *decoded, char *encoded, int sourcelen) {
+       unsigned int ch;
+       int decoded_length = 0;
+       int pos = 0;
+
+       while (pos < sourcelen)
+       {
+               if (!strncmp(&encoded[pos], "=\r\n", 3))
+               {
+                       pos += 3;
+               }
+               else if (!strncmp(&encoded[pos], "=\n", 2))
+               {
+                       pos += 2;
+               }
+               else if (encoded[pos] == '=')
+               {
+                       ch = 0;
+                       sscanf(&encoded[pos+1], "%02x", &ch);
+                       pos += 3;
+                       decoded[decoded_length++] = ch;
+               }
+               else
+               {
+                       decoded[decoded_length++] = encoded[pos];
+                       pos += 1;
+               }
+       }
+       decoded[decoded_length] = 0;
+       return(decoded_length);
+}
+
+
 /*
  * if we send out non ascii subjects, we encode it this way.
  */
@@ -440,12 +488,20 @@ char *rfc2047encode(char *line, long length)
  */
 void striplt(char *buf)
 {
+       size_t len;
+       int a;
+
+       if (buf==NULL) return;
        if (IsEmptyStr(buf)) return;
-        while ((!IsEmptyStr(buf)) && (isspace(buf[0])))
-                strcpy(buf, &buf[1]);
+       len = strlen(buf);
+        while ((!IsEmptyStr(buf)) && (isspace(buf[len - 1])))
+                buf[--len] = 0;
        if (IsEmptyStr(buf)) return;
-        while ((!IsEmptyStr(buf)) && (isspace(buf[strlen(buf) - 1])))
-                buf[strlen(buf) - 1] = 0;
+       a = 0;
+        while ((!IsEmptyStr(buf)) && (isspace(buf[a])))
+               a++;
+       if (a > 0)
+                memmove(buf, &buf[a], len - a + 1);
 }
 
 
@@ -577,6 +633,36 @@ char *memreadline(char *start, char *buf, int maxlen)
 }
 
 
+/** 
+ * \brief Utility function to "readline" from memory
+ * \param start Location in memory from which we are reading.
+ * \param buf the buffer to place the string in.
+ * \param maxlen Size of string buffer
+ * \param retlen the length of the returned string
+ * \return Pointer to the source memory right after we stopped reading.
+ */
+char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
+{
+       char ch;
+       char *ptr;
+       int len = 0;            /**< tally our own length to avoid strlen() delays */
+
+       ptr = start;
+
+       while (1) {
+               ch = *ptr++;
+               if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
+                       buf[len++] = ch;
+               }
+               if ((ch == 10) || (ch == 0)) {
+                       buf[len] = 0;
+                       *retlen = len;
+                       return ptr;
+               }
+       }
+}
+
+
 
 
 /*