aboutsummaryrefslogtreecommitdiffstats
path: root/src/vmime/utility/encoder
diff options
context:
space:
mode:
Diffstat (limited to 'src/vmime/utility/encoder')
-rw-r--r--src/vmime/utility/encoder/b64Encoder.cpp330
-rw-r--r--src/vmime/utility/encoder/b64Encoder.hpp65
-rw-r--r--src/vmime/utility/encoder/binaryEncoder.cpp39
-rw-r--r--src/vmime/utility/encoder/binaryEncoder.hpp52
-rw-r--r--src/vmime/utility/encoder/eightBitEncoder.cpp39
-rw-r--r--src/vmime/utility/encoder/eightBitEncoder.hpp52
-rw-r--r--src/vmime/utility/encoder/encoder.cpp76
-rw-r--r--src/vmime/utility/encoder/encoder.hpp128
-rw-r--r--src/vmime/utility/encoder/encoderFactory.cpp120
-rw-r--r--src/vmime/utility/encoder/encoderFactory.hpp148
-rw-r--r--src/vmime/utility/encoder/noopEncoder.cpp87
-rw-r--r--src/vmime/utility/encoder/noopEncoder.hpp58
-rw-r--r--src/vmime/utility/encoder/qpEncoder.cpp558
-rw-r--r--src/vmime/utility/encoder/qpEncoder.hpp69
-rw-r--r--src/vmime/utility/encoder/sevenBitEncoder.cpp39
-rw-r--r--src/vmime/utility/encoder/sevenBitEncoder.hpp52
-rw-r--r--src/vmime/utility/encoder/uuEncoder.cpp344
-rw-r--r--src/vmime/utility/encoder/uuEncoder.hpp60
18 files changed, 2316 insertions, 0 deletions
diff --git a/src/vmime/utility/encoder/b64Encoder.cpp b/src/vmime/utility/encoder/b64Encoder.cpp
new file mode 100644
index 00000000..274c23c0
--- /dev/null
+++ b/src/vmime/utility/encoder/b64Encoder.cpp
@@ -0,0 +1,330 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/b64Encoder.hpp"
+#include "vmime/parserHelpers.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+b64Encoder::b64Encoder()
+{
+}
+
+
+const std::vector <string> b64Encoder::getAvailableProperties() const
+{
+ std::vector <string> list(encoder::getAvailableProperties());
+
+ list.push_back("maxlinelength");
+
+ return (list);
+}
+
+
+// 7-bits alphabet used to encode binary data
+const unsigned char b64Encoder::sm_alphabet[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+const unsigned char b64Encoder::sm_decodeMap[256] =
+{
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0x00 - 0x0f
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0x10 - 0x1f
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x3e,0xff,0xff,0xff,0x3f, // 0x20 - 0x2f
+ 0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0xff,0xff,0xff,0x3d,0xff,0xff, // 0x30 - 0x3f
+ 0xff,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e, // 0x40 - 0x4f
+ 0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0xff,0xff,0xff,0xff,0xff, // 0x50 - 0x5f
+ 0xff,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28, // 0x60 - 0x6f
+ 0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0xff,0xff,0xff,0xff, // 0x70 - 0x7f
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0x80 - 0x8f
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0x90 - 0x9f
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0xa0 - 0xaf
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0xb0 - 0xbf
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0xc0 - 0xcf
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0xd0 - 0xdf
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0xe0 - 0xef
+ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, // 0xf0 - 0xff
+};
+
+#ifndef VMIME_BUILDING_DOC
+ #define B64_WRITE(s, x, l) s.write(reinterpret_cast <byte_t*>(x), l)
+#endif // VMIME_BUILDING_DOC
+
+
+
+size_t b64Encoder::encode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ const size_t propMaxLineLength =
+ getProperties().getProperty <size_t>("maxlinelength", static_cast <size_t>(-1));
+
+ const bool cutLines = (propMaxLineLength != static_cast <size_t>(-1));
+ const size_t maxLineLength = std::min(propMaxLineLength, static_cast <size_t>(76));
+
+ // Process data
+ byte_t buffer[65536];
+ size_t bufferLength = 0;
+ size_t bufferPos = 0;
+
+ byte_t bytes[3];
+ byte_t output[4];
+
+ size_t total = 0;
+ size_t inTotal = 0;
+
+ size_t curCol = 0;
+
+ if (progress)
+ progress->start(0);
+
+ while (bufferPos < bufferLength || !in.eof())
+ {
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+
+ if (bufferLength == 0)
+ break;
+ }
+
+ // Get 3 bytes of data
+ int count = 0;
+
+ while (count < 3 && bufferPos < bufferLength)
+ bytes[count++] = buffer[bufferPos++];
+
+ while (count < 3)
+ {
+ // There may be more data in the next chunk...
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+
+ if (bufferLength == 0)
+ break;
+ }
+
+ while (count < 3 && bufferPos < bufferLength)
+ bytes[count++] = buffer[bufferPos++];
+ }
+
+ // Encode data
+ switch (count)
+ {
+ case 1:
+
+ output[0] = sm_alphabet[(bytes[0] & 0xFC) >> 2];
+ output[1] = sm_alphabet[(bytes[0] & 0x03) << 4];
+ output[2] = sm_alphabet[64]; // padding
+ output[3] = sm_alphabet[64]; // padding
+
+ break;
+
+ case 2:
+
+ output[0] = sm_alphabet[(bytes[0] & 0xFC) >> 2];
+ output[1] = sm_alphabet[((bytes[0] & 0x03) << 4) | ((bytes[1] & 0xF0) >> 4)];
+ output[2] = sm_alphabet[(bytes[1] & 0x0F) << 2];
+ output[3] = sm_alphabet[64]; // padding
+
+ break;
+
+ default:
+ case 3:
+
+ output[0] = sm_alphabet[(bytes[0] & 0xFC) >> 2];
+ output[1] = sm_alphabet[((bytes[0] & 0x03) << 4) | ((bytes[1] & 0xF0) >> 4)];
+ output[2] = sm_alphabet[((bytes[1] & 0x0F) << 2) | ((bytes[2] & 0xC0) >> 6)];
+ output[3] = sm_alphabet[(bytes[2] & 0x3F)];
+
+ break;
+ }
+
+ // Write encoded data to output stream
+ B64_WRITE(out, output, 4);
+
+ inTotal += count;
+ total += 4;
+ curCol += 4;
+
+ if (cutLines && curCol + 2 /* \r\n */ + 4 /* next bytes */ >= maxLineLength)
+ {
+ out.write("\r\n", 2);
+ curCol = 0;
+ }
+
+ if (progress)
+ progress->progress(inTotal, inTotal);
+ }
+
+ if (progress)
+ progress->stop(inTotal);
+
+ return (total);
+}
+
+
+size_t b64Encoder::decode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ // Process the data
+ byte_t buffer[16384];
+ size_t bufferLength = 0;
+ size_t bufferPos = 0;
+
+ size_t total = 0;
+ size_t inTotal = 0;
+
+ byte_t bytes[4];
+ byte_t output[3];
+
+ if (progress)
+ progress->start(0);
+
+ while (bufferPos < bufferLength || !in.eof())
+ {
+ bytes[0] = '=';
+ bytes[1] = '=';
+ bytes[2] = '=';
+ bytes[3] = '=';
+
+ // Need to get more data?
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+
+ // No more data
+ if (bufferLength == 0)
+ break;
+ }
+
+ // 4 bytes of input provide 3 bytes of output, so
+ // get the next 4 bytes from the input stream.
+ int count = 0;
+
+ while (count < 4 && bufferPos < bufferLength)
+ {
+ const byte_t c = buffer[bufferPos++];
+
+ if (!parserHelpers::isSpace(c))
+ bytes[count++] = c;
+ }
+
+ if (count != 4)
+ {
+ while (count < 4 && !in.eof())
+ {
+ // Data continues on the next chunk
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+
+ while (count < 4 && bufferPos < bufferLength)
+ {
+ const byte_t c = buffer[bufferPos++];
+
+ if (!parserHelpers::isSpace(c))
+ bytes[count++] = c;
+ }
+ }
+ }
+
+ // Decode the bytes
+ byte_t c1 = bytes[0];
+ byte_t c2 = bytes[1];
+
+ if (c1 == '=' || c2 == '=') // end
+ break;
+
+ output[0] = static_cast <byte_t>((sm_decodeMap[c1] << 2) | ((sm_decodeMap[c2] & 0x30) >> 4));
+
+ c1 = bytes[2];
+
+ if (c1 == '=') // end
+ {
+ B64_WRITE(out, output, 1);
+ total += 1;
+ break;
+ }
+
+ output[1] = static_cast <byte_t>(((sm_decodeMap[c2] & 0xf) << 4) | ((sm_decodeMap[c1] & 0x3c) >> 2));
+
+ c2 = bytes[3];
+
+ if (c2 == '=') // end
+ {
+ B64_WRITE(out, output, 2);
+ total += 2;
+ break;
+ }
+
+ output[2] = static_cast <byte_t>(((sm_decodeMap[c1] & 0x03) << 6) | sm_decodeMap[c2]);
+
+ B64_WRITE(out, output, 3);
+ total += 3;
+ inTotal += count;
+
+ if (progress)
+ progress->progress(inTotal, inTotal);
+ }
+
+ if (progress)
+ progress->stop(inTotal);
+
+ return (total);
+}
+
+
+size_t b64Encoder::getEncodedSize(const size_t n) const
+{
+ const size_t propMaxLineLength =
+ getProperties().getProperty <size_t>("maxlinelength", static_cast <size_t>(-1));
+
+ const bool cutLines = (propMaxLineLength != static_cast <size_t>(-1));
+ const size_t maxLineLength = std::min(propMaxLineLength, static_cast <size_t>(76));
+
+ return (n * 4) / 3 // 3 bytes of input provide 4 bytes of output
+ + (cutLines ? (n / maxLineLength) * 2 : 0) // CRLF (2 bytes) for each line.
+ + 4; // padding
+}
+
+
+size_t b64Encoder::getDecodedSize(const size_t n) const
+{
+ // 4 bytes of input provide 3 bytes of output
+ return (n * 3) / 4;
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/b64Encoder.hpp b/src/vmime/utility/encoder/b64Encoder.hpp
new file mode 100644
index 00000000..2d23d9e3
--- /dev/null
+++ b/src/vmime/utility/encoder/b64Encoder.hpp
@@ -0,0 +1,65 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_B64ENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_B64ENCODER_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/encoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** Base64 encoder.
+ */
+
+class VMIME_EXPORT b64Encoder : public encoder
+{
+public:
+
+ b64Encoder();
+
+ size_t encode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+ size_t decode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+
+ const std::vector <string> getAvailableProperties() const;
+
+ size_t getEncodedSize(const size_t n) const;
+ size_t getDecodedSize(const size_t n) const;
+
+protected:
+
+ static const unsigned char sm_alphabet[];
+ static const unsigned char sm_decodeMap[256];
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_B64ENCODER_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/binaryEncoder.cpp b/src/vmime/utility/encoder/binaryEncoder.cpp
new file mode 100644
index 00000000..7d7c40d1
--- /dev/null
+++ b/src/vmime/utility/encoder/binaryEncoder.cpp
@@ -0,0 +1,39 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/binaryEncoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+binaryEncoder::binaryEncoder()
+{
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/binaryEncoder.hpp b/src/vmime/utility/encoder/binaryEncoder.hpp
new file mode 100644
index 00000000..1c831939
--- /dev/null
+++ b/src/vmime/utility/encoder/binaryEncoder.hpp
@@ -0,0 +1,52 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_BINARYENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_BINARYENCODER_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/noopEncoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** Binary encoder.
+ */
+
+class VMIME_EXPORT binaryEncoder : public noopEncoder
+{
+public:
+
+ binaryEncoder();
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_BINARYENCODER_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/eightBitEncoder.cpp b/src/vmime/utility/encoder/eightBitEncoder.cpp
new file mode 100644
index 00000000..4ab07f06
--- /dev/null
+++ b/src/vmime/utility/encoder/eightBitEncoder.cpp
@@ -0,0 +1,39 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/eightBitEncoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+eightBitEncoder::eightBitEncoder()
+{
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/eightBitEncoder.hpp b/src/vmime/utility/encoder/eightBitEncoder.hpp
new file mode 100644
index 00000000..ee50ca95
--- /dev/null
+++ b/src/vmime/utility/encoder/eightBitEncoder.hpp
@@ -0,0 +1,52 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_EIGHTBITENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_EIGHTBITENCODER_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/noopEncoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** 8-bit encoder.
+ */
+
+class VMIME_EXPORT eightBitEncoder : public noopEncoder
+{
+public:
+
+ eightBitEncoder();
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_EIGHTBITENCODER_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/encoder.cpp b/src/vmime/utility/encoder/encoder.cpp
new file mode 100644
index 00000000..b4b13249
--- /dev/null
+++ b/src/vmime/utility/encoder/encoder.cpp
@@ -0,0 +1,76 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/encoder.hpp"
+#include "vmime/exception.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+encoder::encoder()
+{
+}
+
+
+encoder::~encoder()
+{
+}
+
+
+const propertySet& encoder::getProperties() const
+{
+ return (m_props);
+}
+
+
+propertySet& encoder::getProperties()
+{
+ return (m_props);
+}
+
+
+const propertySet& encoder::getResults() const
+{
+ return (m_results);
+}
+
+
+propertySet& encoder::getResults()
+{
+ return (m_results);
+}
+
+
+const std::vector <string> encoder::getAvailableProperties() const
+{
+ std::vector <string> list;
+ return (list);
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/encoder.hpp b/src/vmime/utility/encoder/encoder.hpp
new file mode 100644
index 00000000..34cd10b7
--- /dev/null
+++ b/src/vmime/utility/encoder/encoder.hpp
@@ -0,0 +1,128 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_ENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_ENCODER_HPP_INCLUDED
+
+
+#include "vmime/base.hpp"
+#include "vmime/propertySet.hpp"
+#include "vmime/exception.hpp"
+#include "vmime/utility/progressListener.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** Encode/decode data in different encodings.
+ */
+
+class VMIME_EXPORT encoder : public object
+{
+public:
+
+ encoder();
+ virtual ~encoder();
+
+ /** Encode data.
+ *
+ * @param in input data (decoded)
+ * @param out output stream for encoded data
+ * @param progress progress listener, or NULL if you do not
+ * want to receive progress notifications
+ * @return number of bytes written into output stream
+ */
+ virtual size_t encode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL) = 0;
+
+ /** Decode data.
+ *
+ * @param in input data (encoded)
+ * @param out output stream for decoded data
+ * @param progress progress listener, or NULL if you do not
+ * want to receive progress notifications
+ * @return number of bytes written into output stream
+ */
+ virtual size_t decode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL) = 0;
+
+ /** Return the properties of the encoder.
+ *
+ * @return properties of the encoder
+ */
+ const propertySet& getProperties() const;
+
+ /** Return the properties of the encoder.
+ *
+ * @return properties of the encoder
+ */
+ propertySet& getProperties();
+
+ /** Return a list of property names that can be set for
+ * this encoder.
+ *
+ * @return list of property names
+ */
+ virtual const std::vector <string> getAvailableProperties() const;
+
+ /** Return the results returned by this encoder.
+ *
+ * @return results returned by the encoder
+ */
+ const propertySet& getResults() const;
+
+ /** Return the encoded size for the specified input (decoded) size.
+ * If the size is not exact, it may be an estimate which should always
+ * be larger than the actual encoded size.
+ *
+ * @param n count of input (decoded) bytes
+ * @return count of output (encoded) bytes
+ */
+ virtual size_t getEncodedSize(const size_t n) const = 0;
+
+ /** Return the encoded size for the specified input (encoded) size.
+ * If the size is not exact, it may be an estimate which should always
+ * be larger than the actual decoded size.
+ *
+ * @param n count of input (encoded) bytes
+ * @return count of output (decoded) bytes
+ */
+ virtual size_t getDecodedSize(const size_t n) const = 0;
+
+protected:
+
+ propertySet& getResults();
+
+private:
+
+ propertySet m_props;
+ propertySet m_results;
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_ENCODER_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/encoderFactory.cpp b/src/vmime/utility/encoder/encoderFactory.cpp
new file mode 100644
index 00000000..098a810a
--- /dev/null
+++ b/src/vmime/utility/encoder/encoderFactory.cpp
@@ -0,0 +1,120 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/encoderFactory.hpp"
+#include "vmime/exception.hpp"
+
+#include "vmime/utility/encoder/b64Encoder.hpp"
+#include "vmime/utility/encoder/qpEncoder.hpp"
+#include "vmime/utility/encoder/uuEncoder.hpp"
+#include "vmime/utility/encoder/binaryEncoder.hpp"
+#include "vmime/utility/encoder/sevenBitEncoder.hpp"
+#include "vmime/utility/encoder/eightBitEncoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+encoderFactory::encoderFactory()
+{
+ // Register some default encoders
+ registerName <b64Encoder>("base64");
+ registerName <qpEncoder>("quoted-printable");
+ registerName <uuEncoder>("uuencode");
+ registerName <sevenBitEncoder>("7bit");
+ registerName <eightBitEncoder>("8bit");
+ registerName <binaryEncoder>("binary");
+
+ // Also register some non-standard encoding names
+ registerName <sevenBitEncoder>("7-bit");
+ registerName <eightBitEncoder>("8-bit");
+
+ // Finally, register some bogus encoding names, for compatibility
+ registerName <qpEncoder>("bmoted-printable");
+}
+
+
+encoderFactory::~encoderFactory()
+{
+}
+
+
+shared_ptr <encoderFactory> encoderFactory::getInstance()
+{
+ static encoderFactory instance;
+ return shared_ptr <encoderFactory>(&instance, noop_shared_ptr_deleter <encoderFactory>());
+}
+
+
+shared_ptr <encoder> encoderFactory::create(const string& name)
+{
+ return (getEncoderByName(name)->create());
+}
+
+
+const shared_ptr <const encoderFactory::registeredEncoder> encoderFactory::getEncoderByName(const string& name) const
+{
+ const string lcName(utility::stringUtils::toLower(name));
+
+ for (std::vector <shared_ptr <registeredEncoder> >::const_iterator it = m_encoders.begin() ;
+ it != m_encoders.end() ; ++it)
+ {
+ if ((*it)->getName() == lcName)
+ return (*it);
+ }
+
+ throw exceptions::no_encoder_available(name);
+}
+
+
+size_t encoderFactory::getEncoderCount() const
+{
+ return (m_encoders.size());
+}
+
+
+const shared_ptr <const encoderFactory::registeredEncoder> encoderFactory::getEncoderAt(const size_t pos) const
+{
+ return (m_encoders[pos]);
+}
+
+
+const std::vector <shared_ptr <const encoderFactory::registeredEncoder> > encoderFactory::getEncoderList() const
+{
+ std::vector <shared_ptr <const registeredEncoder> > res;
+
+ for (std::vector <shared_ptr <registeredEncoder> >::const_iterator it = m_encoders.begin() ;
+ it != m_encoders.end() ; ++it)
+ {
+ res.push_back(*it);
+ }
+
+ return (res);
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/encoderFactory.hpp b/src/vmime/utility/encoder/encoderFactory.hpp
new file mode 100644
index 00000000..763cbd5c
--- /dev/null
+++ b/src/vmime/utility/encoder/encoderFactory.hpp
@@ -0,0 +1,148 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_ENCODERFACTORY_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_ENCODERFACTORY_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/encoder.hpp"
+#include "vmime/utility/stringUtils.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** A factory to create 'encoder' objects for the specified encoding.
+ */
+
+class VMIME_EXPORT encoderFactory
+{
+private:
+
+ encoderFactory();
+ ~encoderFactory();
+
+public:
+
+ static shared_ptr <encoderFactory> getInstance();
+
+ /** Information about a registered encoder. */
+ class VMIME_EXPORT registeredEncoder : public object
+ {
+ protected:
+
+ virtual ~registeredEncoder() { }
+
+ public:
+
+ virtual shared_ptr <encoder> create() const = 0;
+
+ virtual const string& getName() const = 0;
+ };
+
+private:
+
+ template <class E>
+ class registeredEncoderImpl : public registeredEncoder
+ {
+ public:
+
+ registeredEncoderImpl(const string& name) : m_name(name) { }
+
+ shared_ptr <encoder> create() const
+ {
+ return vmime::make_shared <E>();
+ }
+
+ const string& getName() const
+ {
+ return (m_name);
+ }
+
+ private:
+
+ const string m_name;
+ };
+
+
+ std::vector <shared_ptr <registeredEncoder> > m_encoders;
+
+public:
+
+ /** Register a new encoder by its encoding name.
+ *
+ * @param name encoding name
+ */
+ template <class E>
+ void registerName(const string& name)
+ {
+ m_encoders.push_back(vmime::make_shared <registeredEncoderImpl <E> >(utility::stringUtils::toLower(name)));
+ }
+
+ /** Create a new encoder instance from an encoding name.
+ *
+ * @param name encoding name (eg. "base64")
+ * @return a new encoder instance for the specified encoding
+ * @throw exceptions::no_encoder_available if no encoder is registered
+ * for this encoding
+ */
+ shared_ptr <encoder> create(const string& name);
+
+ /** Return information about a registered encoder.
+ *
+ * @param name encoding name
+ * @return information about this encoder
+ * @throw exceptions::no_encoder_available if no encoder is registered
+ * for this encoding
+ */
+ const shared_ptr <const registeredEncoder> getEncoderByName(const string& name) const;
+
+ /** Return the number of registered encoders.
+ *
+ * @return number of registered encoders
+ */
+ size_t getEncoderCount() const;
+
+ /** Return the registered encoder at the specified position.
+ *
+ * @param pos position of the registered encoder to return
+ * @return registered encoder at the specified position
+ */
+ const shared_ptr <const registeredEncoder> getEncoderAt(const size_t pos) const;
+
+ /** Return a list of all registered encoders.
+ *
+ * @return list of registered encoders
+ */
+ const std::vector <shared_ptr <const registeredEncoder> > getEncoderList() const;
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_ENCODERFACTORY_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/noopEncoder.cpp b/src/vmime/utility/encoder/noopEncoder.cpp
new file mode 100644
index 00000000..3d991b5d
--- /dev/null
+++ b/src/vmime/utility/encoder/noopEncoder.cpp
@@ -0,0 +1,87 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/noopEncoder.hpp"
+
+#include "vmime/utility/streamUtils.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+noopEncoder::noopEncoder()
+{
+}
+
+
+size_t noopEncoder::encode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ // No encoding performed
+ size_t res = 0;
+
+ if (progress)
+ res = utility::bufferedStreamCopy(in, out, 0, progress);
+ else
+ res = utility::bufferedStreamCopy(in, out);
+
+ return res;
+}
+
+
+size_t noopEncoder::decode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ // No decoding performed
+ size_t res = 0;
+
+ if (progress)
+ res = utility::bufferedStreamCopy(in, out, 0, progress);
+ else
+ res = utility::bufferedStreamCopy(in, out);
+
+ return res;
+}
+
+
+size_t noopEncoder::getEncodedSize(const size_t n) const
+{
+ return n;
+}
+
+
+size_t noopEncoder::getDecodedSize(const size_t n) const
+{
+ return n;
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/noopEncoder.hpp b/src/vmime/utility/encoder/noopEncoder.hpp
new file mode 100644
index 00000000..6314812b
--- /dev/null
+++ b/src/vmime/utility/encoder/noopEncoder.hpp
@@ -0,0 +1,58 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_NOOPENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_NOOPENCODER_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/encoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** Default, no-op encoder (simple copy, no encoding/decoding is performed).
+ */
+
+class VMIME_EXPORT noopEncoder : public encoder
+{
+public:
+
+ noopEncoder();
+
+ size_t encode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+ size_t decode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+
+ size_t getEncodedSize(const size_t n) const;
+ size_t getDecodedSize(const size_t n) const;
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_NOOPENCODER_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/qpEncoder.cpp b/src/vmime/utility/encoder/qpEncoder.cpp
new file mode 100644
index 00000000..c77b5163
--- /dev/null
+++ b/src/vmime/utility/encoder/qpEncoder.cpp
@@ -0,0 +1,558 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/qpEncoder.hpp"
+#include "vmime/parserHelpers.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+qpEncoder::qpEncoder()
+{
+}
+
+
+const std::vector <string> qpEncoder::getAvailableProperties() const
+{
+ std::vector <string> list(encoder::getAvailableProperties());
+
+ list.push_back("maxlinelength");
+
+ list.push_back("text"); // if set, '\r' and '\n' are not hex-encoded.
+ // WARNING! You should not use this for binary data!
+
+ list.push_back("rfc2047"); // for header fields encoding (RFC #2047)
+
+ return (list);
+}
+
+
+
+// Hex-encoding table
+const unsigned char qpEncoder::sm_hexDigits[] = "0123456789ABCDEF";
+
+
+// RFC-2047 encoding table: we always encode RFC-2047 using the restricted
+// charset, that is the one used for 'phrase' in From/To/Cc/... headers.
+//
+// " The set of characters that may be used in a "Q"-encoded 'encoded-word'
+// is restricted to: <upper and lower case ASCII letters, decimal digits,
+// "!", "*", "+", "-", "/", "=", and "_" (underscore, ASCII 95.)>. "
+//
+// Two special cases:
+// - encode space (32) as underscore (95)
+// - encode underscore as hex (=5F)
+//
+// This is a quick lookup table:
+// '1' means "encode", '0' means "no encoding"
+//
+const vmime_uint8 qpEncoder::sm_RFC2047EncodeTable[] =
+{
+ /* 0 NUL */ 1, /* 1 SOH */ 1, /* 2 STX */ 1, /* 3 ETX */ 1, /* 4 EOT */ 1, /* 5 ENQ */ 1,
+ /* 6 ACK */ 1, /* 7 BEL */ 1, /* 8 BS */ 1, /* 9 TAB */ 1, /* 10 LF */ 1, /* 11 VT */ 1,
+ /* 12 FF */ 1, /* 13 CR */ 1, /* 14 SO */ 1, /* 15 SI */ 1, /* 16 DLE */ 1, /* 17 DC1 */ 1,
+ /* 18 DC2 */ 1, /* 19 DC3 */ 1, /* 20 DC4 */ 1, /* 21 NAK */ 1, /* 22 SYN */ 1, /* 23 ETB */ 1,
+ /* 24 CAN */ 1, /* 25 EM */ 1, /* 26 SUB */ 1, /* 27 ESC */ 1, /* 28 FS */ 1, /* 29 GS */ 1,
+ /* 30 RS */ 1, /* 31 US */ 1, /* 32 SPACE*/ 1, /* 33 ! */ 0, /* 34 " */ 1, /* 35 # */ 1,
+ /* 36 $ */ 1, /* 37 % */ 1, /* 38 & */ 1, /* 39 ' */ 1, /* 40 ( */ 1, /* 41 ) */ 1,
+ /* 42 * */ 0, /* 43 + */ 0, /* 44 , */ 1, /* 45 - */ 0, /* 46 . */ 1, /* 47 / */ 0,
+ /* 48 0 */ 0, /* 49 1 */ 0, /* 50 2 */ 0, /* 51 3 */ 0, /* 52 4 */ 0, /* 53 5 */ 0,
+ /* 54 6 */ 0, /* 55 7 */ 0, /* 56 8 */ 0, /* 57 9 */ 0, /* 58 : */ 1, /* 59 ; */ 1,
+ /* 60 < */ 1, /* 61 = */ 1, /* 62 > */ 1, /* 63 ? */ 1, /* 64 @ */ 1, /* 65 A */ 0,
+ /* 66 B */ 0, /* 67 C */ 0, /* 68 D */ 0, /* 69 E */ 0, /* 70 F */ 0, /* 71 G */ 0,
+ /* 72 H */ 0, /* 73 I */ 0, /* 74 J */ 0, /* 75 K */ 0, /* 76 L */ 0, /* 77 M */ 0,
+ /* 78 N */ 0, /* 79 O */ 0, /* 80 P */ 0, /* 81 Q */ 0, /* 82 R */ 0, /* 83 S */ 0,
+ /* 84 T */ 0, /* 85 U */ 0, /* 86 V */ 0, /* 87 W */ 0, /* 88 X */ 0, /* 89 Y */ 0,
+ /* 90 Z */ 0, /* 91 [ */ 1, /* 92 " */ 1, /* 93 ] */ 1, /* 94 ^ */ 1, /* 95 _ */ 1,
+ /* 96 ` */ 1, /* 97 a */ 0, /* 98 b */ 0, /* 99 c */ 0, /* 100 d */ 0, /* 101 e */ 0,
+ /* 102 f */ 0, /* 103 g */ 0, /* 104 h */ 0, /* 105 i */ 0, /* 106 j */ 0, /* 107 k */ 0,
+ /* 108 l */ 0, /* 109 m */ 0, /* 110 n */ 0, /* 111 o */ 0, /* 112 p */ 0, /* 113 q */ 0,
+ /* 114 r */ 0, /* 115 s */ 0, /* 116 t */ 0, /* 117 u */ 0, /* 118 v */ 0, /* 119 w */ 0,
+ /* 120 x */ 0, /* 121 y */ 0, /* 122 z */ 0, /* 123 { */ 1, /* 124 | */ 1, /* 125 } */ 1,
+ /* 126 ~ */ 1, /* 127 DEL */ 1
+};
+
+
+// Hex-decoding table
+const vmime_uint8 qpEncoder::sm_hexDecodeTable[256] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
+ 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+
+// static
+bool qpEncoder::RFC2047_isEncodingNeededForChar(const byte_t c)
+{
+ return (c >= 128 || sm_RFC2047EncodeTable[c] != 0);
+}
+
+
+// static
+int qpEncoder::RFC2047_getEncodedLength(const byte_t c)
+{
+ if (c >= 128 || sm_RFC2047EncodeTable[c] != 0)
+ {
+ if (c == 32) // space
+ {
+ // Encoded as "_"
+ return 1;
+ }
+ else
+ {
+ // Hex encoding
+ return 3;
+ }
+ }
+ else
+ {
+ return 1; // no encoding
+ }
+}
+
+
+#ifndef VMIME_BUILDING_DOC
+
+#define QP_ENCODE_HEX(x) \
+ outBuffer[outBufferPos] = '='; \
+ outBuffer[outBufferPos + 1] = sm_hexDigits[x >> 4]; \
+ outBuffer[outBufferPos + 2] = sm_hexDigits[x & 0xF]; \
+ outBufferPos += 3; \
+ curCol += 3
+
+#define QP_WRITE(s, x, l) s.write(reinterpret_cast <byte_t*>(x), l)
+
+#endif // VMIME_BUILDING_DOC
+
+
+size_t qpEncoder::encode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ const size_t propMaxLineLength =
+ getProperties().getProperty <size_t>("maxlinelength", static_cast <size_t>(-1));
+
+ const bool rfc2047 = getProperties().getProperty <bool>("rfc2047", false);
+ const bool text = getProperties().getProperty <bool>("text", false); // binary mode by default
+
+ const bool cutLines = (propMaxLineLength != static_cast <size_t>(-1));
+ const size_t maxLineLength = std::min(propMaxLineLength, static_cast <size_t>(74));
+
+ // Process the data
+ byte_t buffer[16384];
+ size_t bufferLength = 0;
+ size_t bufferPos = 0;
+
+ size_t curCol = 0;
+
+ byte_t outBuffer[16384];
+ size_t outBufferPos = 0;
+
+ size_t total = 0;
+ size_t inTotal = 0;
+
+ if (progress)
+ progress->start(0);
+
+ while (bufferPos < bufferLength || !in.eof())
+ {
+ // Flush current output buffer
+ if (outBufferPos + 6 >= static_cast <int>(sizeof(outBuffer)))
+ {
+ QP_WRITE(out, outBuffer, outBufferPos);
+
+ total += outBufferPos;
+ outBufferPos = 0;
+ }
+
+ // Need to get more data?
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+
+ // No more data
+ if (bufferLength == 0)
+ break;
+ }
+
+ // Get the next char and encode it
+ const byte_t c = buffer[bufferPos++];
+
+ if (rfc2047)
+ {
+ if (c >= 128 || sm_RFC2047EncodeTable[c] != 0)
+ {
+ if (c == 32) // space
+ {
+ // RFC-2047, Page 5, 4.2. The "Q" encoding:
+ // << The 8-bit hexadecimal value 20 (e.g., ISO-8859-1 SPACE) may be
+ // represented as "_" (underscore, ASCII 95.). >>
+ outBuffer[outBufferPos++] = '_';
+ ++curCol;
+ }
+ else
+ {
+ // Other characters: '=' + hexadecimal encoding
+ QP_ENCODE_HEX(c);
+ }
+ }
+ else
+ {
+ // No encoding
+ outBuffer[outBufferPos++] = c;
+ ++curCol;
+ }
+ }
+ else
+ {
+ switch (c)
+ {
+ case 46: // .
+ {
+ if (curCol == 0)
+ {
+ // If a '.' appears at the beginning of a line, we encode it to
+ // to avoid problems with SMTP servers... ("\r\n.\r\n" means the
+ // end of data transmission).
+ QP_ENCODE_HEX('.');
+ continue;
+ }
+
+ outBuffer[outBufferPos++] = '.';
+ ++curCol;
+ break;
+ }
+ case 32: // space
+ {
+ // Need to get more data?
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+ }
+
+ // Spaces cannot appear at the end of a line. So, encode the space.
+ if (bufferPos >= bufferLength ||
+ (buffer[bufferPos] == '\r' || buffer[bufferPos] == '\n'))
+ {
+ QP_ENCODE_HEX(' ');
+ }
+ else
+ {
+ outBuffer[outBufferPos++] = ' ';
+ ++curCol;
+ }
+
+ break;
+ }
+ case 9: // TAB
+ {
+ QP_ENCODE_HEX(c);
+ break;
+ }
+ case 13: // CR
+ case 10: // LF
+ {
+ // RFC-2045/6.7(4)
+
+ // Text data
+ if (text && !rfc2047)
+ {
+ outBuffer[outBufferPos++] = c;
+ ++curCol;
+ }
+ // Binary data
+ else
+ {
+ QP_ENCODE_HEX(c);
+ }
+
+ break;
+ }
+ case 61: // =
+ {
+ QP_ENCODE_HEX('=');
+ break;
+ }
+ /*
+ Rule #2: (Literal representation) Octets with decimal values of 33
+ through 60 inclusive, and 62 through 126, inclusive, MAY be
+ represented as the ASCII characters which correspond to those
+ octets (EXCLAMATION POINT through LESS THAN, and GREATER THAN
+ through TILDE, respectively).
+ */
+ default:
+
+ //if ((c >= 33 && c <= 60) || (c >= 62 && c <= 126))
+ if (c >= 33 && c <= 126 && c != 61 && c != 63)
+ {
+ outBuffer[outBufferPos++] = c;
+ ++curCol;
+ }
+ // Other characters: '=' + hexadecimal encoding
+ else
+ {
+ QP_ENCODE_HEX(c);
+ }
+
+ break;
+
+ } // switch (c)
+
+ // Soft line break : "=\r\n"
+ if (cutLines && curCol >= maxLineLength - 1)
+ {
+ outBuffer[outBufferPos] = '=';
+ outBuffer[outBufferPos + 1] = '\r';
+ outBuffer[outBufferPos + 2] = '\n';
+
+ outBufferPos += 3;
+ curCol = 0;
+ }
+
+ } // !rfc2047
+
+ ++inTotal;
+
+ if (progress)
+ progress->progress(inTotal, inTotal);
+ }
+
+ // Flush remaining output buffer
+ if (outBufferPos != 0)
+ {
+ QP_WRITE(out, outBuffer, outBufferPos);
+ total += outBufferPos;
+ }
+
+ if (progress)
+ progress->stop(inTotal);
+
+ return (total);
+}
+
+
+size_t qpEncoder::decode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ // Process the data
+ const bool rfc2047 = getProperties().getProperty <bool>("rfc2047", false);
+
+ byte_t buffer[16384];
+ size_t bufferLength = 0;
+ size_t bufferPos = 0;
+
+ byte_t outBuffer[16384];
+ size_t outBufferPos = 0;
+
+ size_t total = 0;
+ size_t inTotal = 0;
+
+ while (bufferPos < bufferLength || !in.eof())
+ {
+ // Flush current output buffer
+ if (outBufferPos >= sizeof(outBuffer))
+ {
+ QP_WRITE(out, outBuffer, outBufferPos);
+
+ total += outBufferPos;
+ outBufferPos = 0;
+ }
+
+ // Need to get more data?
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+
+ // No more data
+ if (bufferLength == 0)
+ break;
+ }
+
+ // Decode the next sequence (hex-encoded byte or printable character)
+ byte_t c = buffer[bufferPos++];
+
+ ++inTotal;
+
+ switch (c)
+ {
+ case '=':
+ {
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+ }
+
+ if (bufferPos < bufferLength)
+ {
+ c = buffer[bufferPos++];
+
+ ++inTotal;
+
+ switch (c)
+ {
+ // Ignore soft line break ("=\r\n" or "=\n")
+ case '\r':
+
+ // Read one byte more
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+ }
+
+ if (bufferPos < bufferLength)
+ {
+ ++bufferPos;
+ ++inTotal;
+ }
+
+ break;
+
+ case '\n':
+
+ break;
+
+ // Hex-encoded char
+ default:
+ {
+ // We need another byte...
+ if (bufferPos >= bufferLength)
+ {
+ bufferLength = in.read(buffer, sizeof(buffer));
+ bufferPos = 0;
+ }
+
+ if (bufferPos < bufferLength)
+ {
+ const byte_t next = buffer[bufferPos++];
+
+ ++inTotal;
+
+ const byte_t value = static_cast <byte_t>
+ (sm_hexDecodeTable[c] * 16 + sm_hexDecodeTable[next]);
+
+ outBuffer[outBufferPos++] = value;
+ }
+ else
+ {
+ // Premature end-of-data
+ }
+
+ break;
+ }
+
+ }
+ }
+ else
+ {
+ // Premature end-of-data
+ }
+
+ break;
+ }
+ case '_':
+ {
+ if (rfc2047)
+ {
+ // RFC-2047, Page 5, 4.2. The "Q" encoding:
+ // << Note that the "_" always represents hexadecimal 20, even if the SPACE
+ // character occupies a different code position in the character set in use. >>
+ outBuffer[outBufferPos++] = 0x20;
+ break;
+ }
+
+ // no break here...
+ }
+ default:
+ {
+ outBuffer[outBufferPos++] = c;
+ }
+
+ }
+
+ if (progress)
+ progress->progress(inTotal, inTotal);
+ }
+
+ // Flush remaining output buffer
+ if (outBufferPos != 0)
+ {
+ QP_WRITE(out, outBuffer, outBufferPos);
+ total += outBufferPos;
+ }
+
+ if (progress)
+ progress->stop(inTotal);
+
+ return (total);
+}
+
+
+size_t qpEncoder::getEncodedSize(const size_t n) const
+{
+ const size_t propMaxLineLength =
+ getProperties().getProperty <size_t>("maxlinelength", static_cast <size_t>(-1));
+
+ const bool cutLines = (propMaxLineLength != static_cast <size_t>(-1));
+ const size_t maxLineLength = std::min(propMaxLineLength, static_cast <size_t>(74));
+
+ // Worst cast: 1 byte of input provide 3 bytes of output
+ // Count CRLF (2 bytes) for each line.
+ return n * 3 + (cutLines ? (n / maxLineLength) * 2 : 0);
+}
+
+
+size_t qpEncoder::getDecodedSize(const size_t n) const
+{
+ // Worst case: 1 byte of input equals 1 byte of output
+ return n;
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/qpEncoder.hpp b/src/vmime/utility/encoder/qpEncoder.hpp
new file mode 100644
index 00000000..c666795b
--- /dev/null
+++ b/src/vmime/utility/encoder/qpEncoder.hpp
@@ -0,0 +1,69 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_QPENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_QPENCODER_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/encoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** Quoted-printable encoder.
+ */
+
+class VMIME_EXPORT qpEncoder : public encoder
+{
+public:
+
+ qpEncoder();
+
+ size_t encode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+ size_t decode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+
+ const std::vector <string> getAvailableProperties() const;
+
+ static bool RFC2047_isEncodingNeededForChar(const unsigned char c);
+ static int RFC2047_getEncodedLength(const unsigned char c);
+
+ size_t getEncodedSize(const size_t n) const;
+ size_t getDecodedSize(const size_t n) const;
+
+protected:
+
+ static const unsigned char sm_hexDigits[17];
+ static const unsigned char sm_hexDecodeTable[256];
+ static const unsigned char sm_RFC2047EncodeTable[128];
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_QPENCODER_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/sevenBitEncoder.cpp b/src/vmime/utility/encoder/sevenBitEncoder.cpp
new file mode 100644
index 00000000..7c76d73f
--- /dev/null
+++ b/src/vmime/utility/encoder/sevenBitEncoder.cpp
@@ -0,0 +1,39 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/sevenBitEncoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+sevenBitEncoder::sevenBitEncoder()
+{
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/sevenBitEncoder.hpp b/src/vmime/utility/encoder/sevenBitEncoder.hpp
new file mode 100644
index 00000000..d260cc7b
--- /dev/null
+++ b/src/vmime/utility/encoder/sevenBitEncoder.hpp
@@ -0,0 +1,52 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_SEVENBITENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_SEVENBITENCODER_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/noopEncoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** 7-bit encoder.
+ */
+
+class VMIME_EXPORT sevenBitEncoder : public noopEncoder
+{
+public:
+
+ sevenBitEncoder();
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_SEVENBITENCODER_HPP_INCLUDED
diff --git a/src/vmime/utility/encoder/uuEncoder.cpp b/src/vmime/utility/encoder/uuEncoder.cpp
new file mode 100644
index 00000000..0375a397
--- /dev/null
+++ b/src/vmime/utility/encoder/uuEncoder.cpp
@@ -0,0 +1,344 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/utility/encoder/uuEncoder.hpp"
+#include "vmime/parserHelpers.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+uuEncoder::uuEncoder()
+{
+ getProperties()["mode"] = 644;
+ getProperties()["filename"] = "no_name";
+ getProperties()["maxlinelength"] = 46;
+}
+
+
+const std::vector <string> uuEncoder::getAvailableProperties() const
+{
+ std::vector <string> list(encoder::getAvailableProperties());
+
+ list.push_back("maxlinelength");
+
+ list.push_back("mode");
+ list.push_back("filename");
+
+ return (list);
+}
+
+
+// This is the character encoding function to make a character printable
+static inline byte_t UUENCODE(const unsigned int c)
+{
+ return static_cast <byte_t>((c & 077) + ' ');
+}
+
+// Single character decoding
+static inline unsigned int UUDECODE(const unsigned int c)
+{
+ return (c - ' ') & 077;
+}
+
+
+size_t uuEncoder::encode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ const string propFilename = getProperties().getProperty <string>("filename", "");
+ const string propMode = getProperties().getProperty <string>("mode", "644");
+
+ const size_t maxLineLength =
+ std::min(getProperties().getProperty <size_t>("maxlinelength", 46), static_cast <size_t>(46));
+
+ size_t total = 0;
+ size_t inTotal = 0;
+
+ // Output the prelude text ("begin [mode] [filename]")
+ out << "begin";
+
+ if (!propFilename.empty())
+ {
+ out << " " << propMode << " " << propFilename;
+ total += 2 + propMode.length() + propFilename.length();
+ }
+
+ out << "\r\n";
+ total += 7;
+
+ // Process the data
+ byte_t inBuffer[64];
+ byte_t outBuffer[64];
+
+ if (progress)
+ progress->start(0);
+
+ while (!in.eof())
+ {
+ // Process up to 45 characters per line
+ std::fill(inBuffer, inBuffer + sizeof(inBuffer), 0);
+
+ const size_t inLength = in.read(inBuffer, maxLineLength - 1);
+
+ outBuffer[0] = UUENCODE(static_cast <unsigned int>(inLength)); // Line length
+
+ size_t j = 1;
+
+ for (size_t i = 0 ; i < inLength ; i += 3, j += 4)
+ {
+ const byte_t c1 = inBuffer[i];
+ const byte_t c2 = inBuffer[i + 1];
+ const byte_t c3 = inBuffer[i + 2];
+
+ outBuffer[j] = UUENCODE(c1 >> 2);
+ outBuffer[j + 1] = UUENCODE(((c1 << 4) & 060) | ((c2 >> 4) & 017));
+ outBuffer[j + 2] = UUENCODE(((c2 << 2) & 074) | ((c3 >> 6) & 03));
+ outBuffer[j + 3] = UUENCODE(c3 & 077);
+ }
+
+ outBuffer[j] = '\r';
+ outBuffer[j + 1] = '\n';
+
+ out.write(outBuffer, j + 2);
+
+ total += j + 2;
+ inTotal += inLength;
+
+ if (progress)
+ progress->progress(inTotal, inTotal);
+ }
+
+ out << "end\r\n";
+ total += 5;
+
+ if (progress)
+ progress->stop(inTotal);
+
+ return (total);
+}
+
+
+size_t uuEncoder::decode(utility::inputStream& in,
+ utility::outputStream& out, utility::progressListener* progress)
+{
+ in.reset(); // may not work...
+
+ // Process the data
+ byte_t inBuffer[64];
+ byte_t outBuffer[64];
+
+ size_t total = 0;
+ size_t inTotal = 0;
+
+ bool stop = false;
+
+ std::fill(inBuffer, inBuffer + sizeof(inBuffer), 0);
+
+ if (progress)
+ progress->start(0);
+
+ while (!stop && !in.eof())
+ {
+ // Get the line length
+ byte_t lengthChar;
+
+ if (in.read(&lengthChar, 1) == 0)
+ break;
+
+ const size_t outLength = UUDECODE(lengthChar);
+ const size_t inLength = std::min((outLength * 4) / 3, static_cast <size_t>(64));
+ size_t inPos = 0;
+
+ switch (lengthChar)
+ {
+ case ' ':
+ case '\t':
+ case '\r':
+ case '\n':
+ {
+ // Ignore
+ continue;
+ }
+ case 'b':
+ {
+ // Read 5 characters more to check for begin ("begin ...\r\n" or "begin ...\n")
+ inPos = in.read(inBuffer, 5);
+
+ if (inPos == 5 &&
+ inBuffer[0] == 'e' &&
+ inBuffer[1] == 'g' &&
+ inBuffer[2] == 'i' &&
+ inBuffer[3] == 'n' &&
+ parserHelpers::isSpace(inBuffer[4]))
+ {
+ inTotal += 5;
+
+ byte_t c = 0;
+
+ size_t count = 0;
+ byte_t buffer[512];
+
+ while (count < sizeof(buffer) - 1 && in.read(&c, 1) == 1)
+ {
+ if (c == '\n')
+ break;
+
+ buffer[count++] = c;
+ }
+
+ inTotal += count;
+
+ if (c != '\n')
+ {
+ // OOPS! Weird line. Don't try to decode more...
+
+ if (progress)
+ progress->stop(inTotal);
+
+ return (total);
+ }
+
+ // Parse filename and mode
+ if (count > 0)
+ {
+ buffer[count] = '\0';
+
+ byte_t* p = buffer;
+
+ while (*p && parserHelpers::isSpace(*p)) ++p;
+
+ byte_t* modeStart = buffer;
+
+ while (*p && !parserHelpers::isSpace(*p)) ++p;
+
+ getResults()["mode"] = string(modeStart, p);
+
+ while (*p && parserHelpers::isSpace(*p)) ++p;
+
+ byte_t* filenameStart = buffer;
+
+ while (*p && !(*p == '\r' || *p == '\n')) ++p;
+
+ getResults()["filename"] = string(filenameStart, p);
+ }
+ // No filename or mode specified
+ else
+ {
+ getResults()["filename"] = "untitled";
+ getResults()["mode"] = 644;
+ }
+
+ continue;
+ }
+
+ break;
+ }
+ case 'e':
+ {
+ // Read 3 characters more to check for end ("end\r\n" or "end\n")
+ inPos = in.read(inBuffer, 3);
+
+ if (inPos == 3 &&
+ inBuffer[0] == 'n' &&
+ inBuffer[1] == 'd' &&
+ (inBuffer[2] == '\r' || inBuffer[2] == '\n'))
+ {
+ stop = true;
+ inTotal += 3;
+ continue;
+ }
+
+ break;
+ }
+
+ }
+
+ // Read encoded data
+ if (in.read(inBuffer + inPos, inLength - inPos) != inLength - inPos)
+ {
+ // Premature end of data
+ break;
+ }
+
+ inTotal += (inLength - inPos);
+
+ // Decode data
+ for (size_t i = 0, j = 0 ; i < inLength ; i += 4, j += 3)
+ {
+ const byte_t c1 = inBuffer[i];
+ const byte_t c2 = inBuffer[i + 1];
+ const byte_t c3 = inBuffer[i + 2];
+ const byte_t c4 = inBuffer[i + 3];
+
+ const size_t n = std::min(inLength - i, static_cast <size_t>(3));
+
+ switch (n)
+ {
+ default:
+ case 3: outBuffer[j + 2] = static_cast <byte_t>(UUDECODE(c3) << 6 | UUDECODE(c4));
+ case 2: outBuffer[j + 1] = static_cast <byte_t>(UUDECODE(c2) << 4 | UUDECODE(c3) >> 2);
+ case 1: outBuffer[j] = static_cast <byte_t>(UUDECODE(c1) << 2 | UUDECODE(c2) >> 4);
+ case 0: break;
+ }
+
+ total += n;
+ }
+
+ out.write(outBuffer, outLength);
+
+ std::fill(inBuffer, inBuffer + sizeof(inBuffer), 0);
+
+ if (progress)
+ progress->progress(inTotal, inTotal);
+ }
+
+ if (progress)
+ progress->stop(inTotal);
+
+ return (total);
+}
+
+
+size_t uuEncoder::getEncodedSize(const size_t n) const
+{
+ // 3 bytes of input provide 4 bytes of output.
+ // Count CRLF (2 bytes) for each line of 45 characters.
+ // Also reserve some space for header and footer.
+ return 200 + n * 3 + (n / 45) * 2;
+}
+
+
+size_t uuEncoder::getDecodedSize(const size_t n) const
+{
+ // 4 bytes of input provide 3 bytes of output
+ return (n * 3) / 4;
+}
+
+
+} // encoder
+} // utility
+} // vmime
diff --git a/src/vmime/utility/encoder/uuEncoder.hpp b/src/vmime/utility/encoder/uuEncoder.hpp
new file mode 100644
index 00000000..7365263c
--- /dev/null
+++ b/src/vmime/utility/encoder/uuEncoder.hpp
@@ -0,0 +1,60 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002-2013 Vincent Richard <[email protected]>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library. Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_UTILITY_ENCODER_UUENCODER_HPP_INCLUDED
+#define VMIME_UTILITY_ENCODER_UUENCODER_HPP_INCLUDED
+
+
+#include "vmime/utility/encoder/encoder.hpp"
+
+
+namespace vmime {
+namespace utility {
+namespace encoder {
+
+
+/** UUEncode encoder.
+ */
+
+class VMIME_EXPORT uuEncoder : public encoder
+{
+public:
+
+ uuEncoder();
+
+ size_t encode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+ size_t decode(utility::inputStream& in, utility::outputStream& out, utility::progressListener* progress = NULL);
+
+ const std::vector <string> getAvailableProperties() const;
+
+ size_t getEncodedSize(const size_t n) const;
+ size_t getDecodedSize(const size_t n) const;
+};
+
+
+} // encoder
+} // utility
+} // vmime
+
+
+#endif // VMIME_UTILITY_ENCODER_UUENCODER_HPP_INCLUDED
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-20 07:18:34 +0000