summaryrefslogtreecommitdiff
path: root/ThirdParty/luasocket/src/mime.c
diff options
context:
space:
mode:
Diffstat (limited to 'ThirdParty/luasocket/src/mime.c')
-rw-r--r--ThirdParty/luasocket/src/mime.c852
1 files changed, 852 insertions, 0 deletions
diff --git a/ThirdParty/luasocket/src/mime.c b/ThirdParty/luasocket/src/mime.c
new file mode 100644
index 0000000..6c210e4
--- /dev/null
+++ b/ThirdParty/luasocket/src/mime.c
@@ -0,0 +1,852 @@
+/*=========================================================================*\
+* MIME support functions
+* LuaSocket toolkit
+\*=========================================================================*/
+#include "luasocket.h"
+#include "mime.h"
+#include <string.h>
+#include <ctype.h>
+
+/*=========================================================================*\
+* Don't want to trust escape character constants
+\*=========================================================================*/
+typedef unsigned char UC;
+static const char CRLF[] = "\r\n";
+static const char EQCRLF[] = "=\r\n";
+
+/*=========================================================================*\
+* Internal function prototypes.
+\*=========================================================================*/
+static int mime_global_wrp(lua_State *L);
+static int mime_global_b64(lua_State *L);
+static int mime_global_unb64(lua_State *L);
+static int mime_global_qp(lua_State *L);
+static int mime_global_unqp(lua_State *L);
+static int mime_global_qpwrp(lua_State *L);
+static int mime_global_eol(lua_State *L);
+static int mime_global_dot(lua_State *L);
+
+static size_t dot(int c, size_t state, luaL_Buffer *buffer);
+//static void b64setup(UC *base);
+static size_t b64encode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
+static size_t b64pad(const UC *input, size_t size, luaL_Buffer *buffer);
+static size_t b64decode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
+
+//static void qpsetup(UC *class, UC *unbase);
+static void qpquote(UC c, luaL_Buffer *buffer);
+static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
+static size_t qpencode(UC c, UC *input, size_t size,
+ const char *marker, luaL_Buffer *buffer);
+static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer);
+
+/* code support functions */
+static luaL_Reg func[] = {
+ { "dot", mime_global_dot },
+ { "b64", mime_global_b64 },
+ { "eol", mime_global_eol },
+ { "qp", mime_global_qp },
+ { "qpwrp", mime_global_qpwrp },
+ { "unb64", mime_global_unb64 },
+ { "unqp", mime_global_unqp },
+ { "wrp", mime_global_wrp },
+ { NULL, NULL }
+};
+
+/*-------------------------------------------------------------------------*\
+* Quoted-printable globals
+\*-------------------------------------------------------------------------*/
+enum {QP_PLAIN, QP_QUOTED, QP_CR, QP_IF_LAST};
+
+static const UC qpclass[] = {
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_IF_LAST, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_CR, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_IF_LAST, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_QUOTED, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN, QP_PLAIN,
+ QP_PLAIN, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED,
+ QP_QUOTED, QP_QUOTED, QP_QUOTED, QP_QUOTED
+};
+
+static const UC qpbase[] = "0123456789ABCDEF";
+
+static const UC qpunbase[] = {
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255,
+ 255, 255, 255, 255, 255, 255, 10, 11, 12, 13, 14, 15,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 10, 11, 12, 13, 14, 15, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255
+};
+
+/*-------------------------------------------------------------------------*\
+* Base64 globals
+\*-------------------------------------------------------------------------*/
+static const UC b64base[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static const UC b64unbase[] = {
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0,
+ 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255,
+ 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+ 51, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255
+};
+
+/*=========================================================================*\
+* Exported functions
+\*=========================================================================*/
+/*-------------------------------------------------------------------------*\
+* Initializes module
+\*-------------------------------------------------------------------------*/
+LUASOCKET_API int luaopen_mime_core(lua_State *L)
+{
+ lua_newtable(L);
+ luaL_setfuncs(L, func, 0);
+ /* make version string available to scripts */
+ lua_pushstring(L, "_VERSION");
+ lua_pushstring(L, MIME_VERSION);
+ lua_rawset(L, -3);
+ /* initialize lookup tables */
+ // qpsetup(qpclass, qpunbase);
+ // b64setup(b64unbase);
+ return 1;
+}
+
+/*=========================================================================*\
+* Global Lua functions
+\*=========================================================================*/
+/*-------------------------------------------------------------------------*\
+* Incrementaly breaks a string into lines. The string can have CRLF breaks.
+* A, n = wrp(l, B, length)
+* A is a copy of B, broken into lines of at most 'length' bytes.
+* 'l' is how many bytes are left for the first line of B.
+* 'n' is the number of bytes left in the last line of A.
+\*-------------------------------------------------------------------------*/
+static int mime_global_wrp(lua_State *L)
+{
+ size_t size = 0;
+ int left = (int) luaL_checknumber(L, 1);
+ const UC *input = (const UC *) luaL_optlstring(L, 2, NULL, &size);
+ const UC *last = input + size;
+ int length = (int) luaL_optnumber(L, 3, 76);
+ luaL_Buffer buffer;
+ /* end of input black-hole */
+ if (!input) {
+ /* if last line has not been terminated, add a line break */
+ if (left < length) lua_pushstring(L, CRLF);
+ /* otherwise, we are done */
+ else lua_pushnil(L);
+ lua_pushnumber(L, length);
+ return 2;
+ }
+ luaL_buffinit(L, &buffer);
+ while (input < last) {
+ switch (*input) {
+ case '\r':
+ break;
+ case '\n':
+ luaL_addstring(&buffer, CRLF);
+ left = length;
+ break;
+ default:
+ if (left <= 0) {
+ left = length;
+ luaL_addstring(&buffer, CRLF);
+ }
+ luaL_addchar(&buffer, *input);
+ left--;
+ break;
+ }
+ input++;
+ }
+ luaL_pushresult(&buffer);
+ lua_pushnumber(L, left);
+ return 2;
+}
+
+#if 0
+/*-------------------------------------------------------------------------*\
+* Fill base64 decode map.
+\*-------------------------------------------------------------------------*/
+static void b64setup(UC *unbase)
+{
+ int i;
+ for (i = 0; i <= 255; i++) unbase[i] = (UC) 255;
+ for (i = 0; i < 64; i++) unbase[b64base[i]] = (UC) i;
+ unbase['='] = 0;
+
+ printf("static const UC b64unbase[] = {\n");
+ for (int i = 0; i < 256; i++) {
+ printf("%d, ", unbase[i]);
+ }
+ printf("\n}\n;");
+}
+#endif
+
+/*-------------------------------------------------------------------------*\
+* Acumulates bytes in input buffer until 3 bytes are available.
+* Translate the 3 bytes into Base64 form and append to buffer.
+* Returns new number of bytes in buffer.
+\*-------------------------------------------------------------------------*/
+static size_t b64encode(UC c, UC *input, size_t size,
+ luaL_Buffer *buffer)
+{
+ input[size++] = c;
+ if (size == 3) {
+ UC code[4];
+ unsigned long value = 0;
+ value += input[0]; value <<= 8;
+ value += input[1]; value <<= 8;
+ value += input[2];
+ code[3] = b64base[value & 0x3f]; value >>= 6;
+ code[2] = b64base[value & 0x3f]; value >>= 6;
+ code[1] = b64base[value & 0x3f]; value >>= 6;
+ code[0] = b64base[value];
+ luaL_addlstring(buffer, (char *) code, 4);
+ size = 0;
+ }
+ return size;
+}
+
+/*-------------------------------------------------------------------------*\
+* Encodes the Base64 last 1 or 2 bytes and adds padding '='
+* Result, if any, is appended to buffer.
+* Returns 0.
+\*-------------------------------------------------------------------------*/
+static size_t b64pad(const UC *input, size_t size,
+ luaL_Buffer *buffer)
+{
+ unsigned long value = 0;
+ UC code[4] = {'=', '=', '=', '='};
+ switch (size) {
+ case 1:
+ value = input[0] << 4;
+ code[1] = b64base[value & 0x3f]; value >>= 6;
+ code[0] = b64base[value];
+ luaL_addlstring(buffer, (char *) code, 4);
+ break;
+ case 2:
+ value = input[0]; value <<= 8;
+ value |= input[1]; value <<= 2;
+ code[2] = b64base[value & 0x3f]; value >>= 6;
+ code[1] = b64base[value & 0x3f]; value >>= 6;
+ code[0] = b64base[value];
+ luaL_addlstring(buffer, (char *) code, 4);
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+/*-------------------------------------------------------------------------*\
+* Acumulates bytes in input buffer until 4 bytes are available.
+* Translate the 4 bytes from Base64 form and append to buffer.
+* Returns new number of bytes in buffer.
+\*-------------------------------------------------------------------------*/
+static size_t b64decode(UC c, UC *input, size_t size,
+ luaL_Buffer *buffer)
+{
+ /* ignore invalid characters */
+ if (b64unbase[c] > 64) return size;
+ input[size++] = c;
+ /* decode atom */
+ if (size == 4) {
+ UC decoded[3];
+ int valid, value = 0;
+ value = b64unbase[input[0]]; value <<= 6;
+ value |= b64unbase[input[1]]; value <<= 6;
+ value |= b64unbase[input[2]]; value <<= 6;
+ value |= b64unbase[input[3]];
+ decoded[2] = (UC) (value & 0xff); value >>= 8;
+ decoded[1] = (UC) (value & 0xff); value >>= 8;
+ decoded[0] = (UC) value;
+ /* take care of paddding */
+ valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3;
+ luaL_addlstring(buffer, (char *) decoded, valid);
+ return 0;
+ /* need more data */
+ } else return size;
+}
+
+/*-------------------------------------------------------------------------*\
+* Incrementally applies the Base64 transfer content encoding to a string
+* A, B = b64(C, D)
+* A is the encoded version of the largest prefix of C .. D that is
+* divisible by 3. B has the remaining bytes of C .. D, *without* encoding.
+* The easiest thing would be to concatenate the two strings and
+* encode the result, but we can't afford that or Lua would dupplicate
+* every chunk we received.
+\*-------------------------------------------------------------------------*/
+static int mime_global_b64(lua_State *L)
+{
+ UC atom[3];
+ size_t isize = 0, asize = 0;
+ const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+ const UC *last = input + isize;
+ luaL_Buffer buffer;
+ /* end-of-input blackhole */
+ if (!input) {
+ lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* make sure we don't confuse buffer stuff with arguments */
+ lua_settop(L, 2);
+ /* process first part of the input */
+ luaL_buffinit(L, &buffer);
+ while (input < last)
+ asize = b64encode(*input++, atom, asize, &buffer);
+ input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+ /* if second part is nil, we are done */
+ if (!input) {
+ size_t osize = 0;
+ asize = b64pad(atom, asize, &buffer);
+ luaL_pushresult(&buffer);
+ /* if the output is empty and the input is nil, return nil */
+ lua_tolstring(L, -1, &osize);
+ if (osize == 0) lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* otherwise process the second part */
+ last = input + isize;
+ while (input < last)
+ asize = b64encode(*input++, atom, asize, &buffer);
+ luaL_pushresult(&buffer);
+ lua_pushlstring(L, (char *) atom, asize);
+ return 2;
+}
+
+/*-------------------------------------------------------------------------*\
+* Incrementally removes the Base64 transfer content encoding from a string
+* A, B = b64(C, D)
+* A is the encoded version of the largest prefix of C .. D that is
+* divisible by 4. B has the remaining bytes of C .. D, *without* encoding.
+\*-------------------------------------------------------------------------*/
+static int mime_global_unb64(lua_State *L)
+{
+ UC atom[4];
+ size_t isize = 0, asize = 0;
+ const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+ const UC *last = input + isize;
+ luaL_Buffer buffer;
+ /* end-of-input blackhole */
+ if (!input) {
+ lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* make sure we don't confuse buffer stuff with arguments */
+ lua_settop(L, 2);
+ /* process first part of the input */
+ luaL_buffinit(L, &buffer);
+ while (input < last)
+ asize = b64decode(*input++, atom, asize, &buffer);
+ input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+ /* if second is nil, we are done */
+ if (!input) {
+ size_t osize = 0;
+ luaL_pushresult(&buffer);
+ /* if the output is empty and the input is nil, return nil */
+ lua_tolstring(L, -1, &osize);
+ if (osize == 0) lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* otherwise, process the rest of the input */
+ last = input + isize;
+ while (input < last)
+ asize = b64decode(*input++, atom, asize, &buffer);
+ luaL_pushresult(&buffer);
+ lua_pushlstring(L, (char *) atom, asize);
+ return 2;
+}
+
+/*-------------------------------------------------------------------------*\
+* Quoted-printable encoding scheme
+* all (except CRLF in text) can be =XX
+* CLRL in not text must be =XX=XX
+* 33 through 60 inclusive can be plain
+* 62 through 126 inclusive can be plain
+* 9 and 32 can be plain, unless in the end of a line, where must be =XX
+* encoded lines must be no longer than 76 not counting CRLF
+* soft line-break are =CRLF
+* To encode one byte, we need to see the next two.
+* Worst case is when we see a space, and wonder if a CRLF is comming
+\*-------------------------------------------------------------------------*/
+#if 0
+/*-------------------------------------------------------------------------*\
+* Split quoted-printable characters into classes
+* Precompute reverse map for encoding
+\*-------------------------------------------------------------------------*/
+static void qpsetup(UC *cl, UC *unbase)
+{
+
+ int i;
+ for (i = 0; i < 256; i++) cl[i] = QP_QUOTED;
+ for (i = 33; i <= 60; i++) cl[i] = QP_PLAIN;
+ for (i = 62; i <= 126; i++) cl[i] = QP_PLAIN;
+ cl['\t'] = QP_IF_LAST;
+ cl[' '] = QP_IF_LAST;
+ cl['\r'] = QP_CR;
+ for (i = 0; i < 256; i++) unbase[i] = 255;
+ unbase['0'] = 0; unbase['1'] = 1; unbase['2'] = 2;
+ unbase['3'] = 3; unbase['4'] = 4; unbase['5'] = 5;
+ unbase['6'] = 6; unbase['7'] = 7; unbase['8'] = 8;
+ unbase['9'] = 9; unbase['A'] = 10; unbase['a'] = 10;
+ unbase['B'] = 11; unbase['b'] = 11; unbase['C'] = 12;
+ unbase['c'] = 12; unbase['D'] = 13; unbase['d'] = 13;
+ unbase['E'] = 14; unbase['e'] = 14; unbase['F'] = 15;
+ unbase['f'] = 15;
+
+printf("static UC qpclass[] = {");
+ for (int i = 0; i < 256; i++) {
+ if (i % 6 == 0) {
+ printf("\n ");
+ }
+ switch(cl[i]) {
+ case QP_QUOTED:
+ printf("QP_QUOTED, ");
+ break;
+ case QP_PLAIN:
+ printf("QP_PLAIN, ");
+ break;
+ case QP_CR:
+ printf("QP_CR, ");
+ break;
+ case QP_IF_LAST:
+ printf("QP_IF_LAST, ");
+ break;
+ }
+ }
+printf("\n};\n");
+
+printf("static const UC qpunbase[] = {");
+ for (int i = 0; i < 256; i++) {
+ int c = qpunbase[i];
+ printf("%d, ", c);
+ }
+printf("\";\n");
+}
+#endif
+
+/*-------------------------------------------------------------------------*\
+* Output one character in form =XX
+\*-------------------------------------------------------------------------*/
+static void qpquote(UC c, luaL_Buffer *buffer)
+{
+ luaL_addchar(buffer, '=');
+ luaL_addchar(buffer, qpbase[c >> 4]);
+ luaL_addchar(buffer, qpbase[c & 0x0F]);
+}
+
+/*-------------------------------------------------------------------------*\
+* Accumulate characters until we are sure about how to deal with them.
+* Once we are sure, output to the buffer, in the correct form.
+\*-------------------------------------------------------------------------*/
+static size_t qpencode(UC c, UC *input, size_t size,
+ const char *marker, luaL_Buffer *buffer)
+{
+ input[size++] = c;
+ /* deal with all characters we can have */
+ while (size > 0) {
+ switch (qpclass[input[0]]) {
+ /* might be the CR of a CRLF sequence */
+ case QP_CR:
+ if (size < 2) return size;
+ if (input[1] == '\n') {
+ luaL_addstring(buffer, marker);
+ return 0;
+ } else qpquote(input[0], buffer);
+ break;
+ /* might be a space and that has to be quoted if last in line */
+ case QP_IF_LAST:
+ if (size < 3) return size;
+ /* if it is the last, quote it and we are done */
+ if (input[1] == '\r' && input[2] == '\n') {
+ qpquote(input[0], buffer);
+ luaL_addstring(buffer, marker);
+ return 0;
+ } else luaL_addchar(buffer, input[0]);
+ break;
+ /* might have to be quoted always */
+ case QP_QUOTED:
+ qpquote(input[0], buffer);
+ break;
+ /* might never have to be quoted */
+ default:
+ luaL_addchar(buffer, input[0]);
+ break;
+ }
+ input[0] = input[1]; input[1] = input[2];
+ size--;
+ }
+ return 0;
+}
+
+/*-------------------------------------------------------------------------*\
+* Deal with the final characters
+\*-------------------------------------------------------------------------*/
+static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer)
+{
+ size_t i;
+ for (i = 0; i < size; i++) {
+ if (qpclass[input[i]] == QP_PLAIN) luaL_addchar(buffer, input[i]);
+ else qpquote(input[i], buffer);
+ }
+ if (size > 0) luaL_addstring(buffer, EQCRLF);
+ return 0;
+}
+
+/*-------------------------------------------------------------------------*\
+* Incrementally converts a string to quoted-printable
+* A, B = qp(C, D, marker)
+* Marker is the text to be used to replace CRLF sequences found in A.
+* A is the encoded version of the largest prefix of C .. D that
+* can be encoded without doubts.
+* B has the remaining bytes of C .. D, *without* encoding.
+\*-------------------------------------------------------------------------*/
+static int mime_global_qp(lua_State *L)
+{
+ size_t asize = 0, isize = 0;
+ UC atom[3];
+ const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+ const UC *last = input + isize;
+ const char *marker = luaL_optstring(L, 3, CRLF);
+ luaL_Buffer buffer;
+ /* end-of-input blackhole */
+ if (!input) {
+ lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* make sure we don't confuse buffer stuff with arguments */
+ lua_settop(L, 3);
+ /* process first part of input */
+ luaL_buffinit(L, &buffer);
+ while (input < last)
+ asize = qpencode(*input++, atom, asize, marker, &buffer);
+ input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+ /* if second part is nil, we are done */
+ if (!input) {
+ asize = qppad(atom, asize, &buffer);
+ luaL_pushresult(&buffer);
+ if (!(*lua_tostring(L, -1))) lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* otherwise process rest of input */
+ last = input + isize;
+ while (input < last)
+ asize = qpencode(*input++, atom, asize, marker, &buffer);
+ luaL_pushresult(&buffer);
+ lua_pushlstring(L, (char *) atom, asize);
+ return 2;
+}
+
+/*-------------------------------------------------------------------------*\
+* Accumulate characters until we are sure about how to deal with them.
+* Once we are sure, output the to the buffer, in the correct form.
+\*-------------------------------------------------------------------------*/
+static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
+ int d;
+ input[size++] = c;
+ /* deal with all characters we can deal */
+ switch (input[0]) {
+ /* if we have an escape character */
+ case '=':
+ if (size < 3) return size;
+ /* eliminate soft line break */
+ if (input[1] == '\r' && input[2] == '\n') return 0;
+ /* decode quoted representation */
+ c = qpunbase[input[1]]; d = qpunbase[input[2]];
+ /* if it is an invalid, do not decode */
+ if (c > 15 || d > 15) luaL_addlstring(buffer, (char *)input, 3);
+ else luaL_addchar(buffer, (char) ((c << 4) + d));
+ return 0;
+ case '\r':
+ if (size < 2) return size;
+ if (input[1] == '\n') luaL_addlstring(buffer, (char *)input, 2);
+ return 0;
+ default:
+ if (input[0] == '\t' || (input[0] > 31 && input[0] < 127))
+ luaL_addchar(buffer, input[0]);
+ return 0;
+ }
+}
+
+/*-------------------------------------------------------------------------*\
+* Incrementally decodes a string in quoted-printable
+* A, B = qp(C, D)
+* A is the decoded version of the largest prefix of C .. D that
+* can be decoded without doubts.
+* B has the remaining bytes of C .. D, *without* decoding.
+\*-------------------------------------------------------------------------*/
+static int mime_global_unqp(lua_State *L)
+{
+ size_t asize = 0, isize = 0;
+ UC atom[3];
+ const UC *input = (const UC *) luaL_optlstring(L, 1, NULL, &isize);
+ const UC *last = input + isize;
+ luaL_Buffer buffer;
+ /* end-of-input blackhole */
+ if (!input) {
+ lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* make sure we don't confuse buffer stuff with arguments */
+ lua_settop(L, 2);
+ /* process first part of input */
+ luaL_buffinit(L, &buffer);
+ while (input < last)
+ asize = qpdecode(*input++, atom, asize, &buffer);
+ input = (const UC *) luaL_optlstring(L, 2, NULL, &isize);
+ /* if second part is nil, we are done */
+ if (!input) {
+ luaL_pushresult(&buffer);
+ if (!(*lua_tostring(L, -1))) lua_pushnil(L);
+ lua_pushnil(L);
+ return 2;
+ }
+ /* otherwise process rest of input */
+ last = input + isize;
+ while (input < last)
+ asize = qpdecode(*input++, atom, asize, &buffer);
+ luaL_pushresult(&buffer);
+ lua_pushlstring(L, (char *) atom, asize);
+ return 2;
+}
+
+/*-------------------------------------------------------------------------*\
+* Incrementally breaks a quoted-printed string into lines
+* A, n = qpwrp(l, B, length)
+* A is a copy of B, broken into lines of at most 'length' bytes.
+* 'l' is how many bytes are left for the first line of B.
+* 'n' is the number of bytes left in the last line of A.
+* There are two complications: lines can't be broken in the middle
+* of an encoded =XX, and there might be line breaks already
+\*-------------------------------------------------------------------------*/
+static int mime_global_qpwrp(lua_State *L)
+{
+ size_t size = 0;
+ int left = (int) luaL_checknumber(L, 1);
+ const UC *input = (const UC *) luaL_optlstring(L, 2, NULL, &size);
+ const UC *last = input + size;
+ int length = (int) luaL_optnumber(L, 3, 76);
+ luaL_Buffer buffer;
+ /* end-of-input blackhole */
+ if (!input) {
+ if (left < length) lua_pushstring(L, EQCRLF);
+ else lua_pushnil(L);
+ lua_pushnumber(L, length);
+ return 2;
+ }
+ /* process all input */
+ luaL_buffinit(L, &buffer);
+ while (input < last) {
+ switch (*input) {
+ case '\r':
+ break;
+ case '\n':
+ left = length;
+ luaL_addstring(&buffer, CRLF);
+ break;
+ case '=':
+ if (left <= 3) {
+ left = length;
+ luaL_addstring(&buffer, EQCRLF);
+ }
+ luaL_addchar(&buffer, *input);
+ left--;
+ break;
+ default:
+ if (left <= 1) {
+ left = length;
+ luaL_addstring(&buffer, EQCRLF);
+ }
+ luaL_addchar(&buffer, *input);
+ left--;
+ break;
+ }
+ input++;
+ }
+ luaL_pushresult(&buffer);
+ lua_pushnumber(L, left);
+ return 2;
+}
+
+/*-------------------------------------------------------------------------*\
+* Here is what we do: \n, and \r are considered candidates for line
+* break. We issue *one* new line marker if any of them is seen alone, or
+* followed by a different one. That is, \n\n and \r\r will issue two
+* end of line markers each, but \r\n, \n\r etc will only issue *one*
+* marker. This covers Mac OS, Mac OS X, VMS, Unix and DOS, as well as
+* probably other more obscure conventions.
+*
+* c is the current character being processed
+* last is the previous character
+\*-------------------------------------------------------------------------*/
+#define eolcandidate(c) (c == '\r' || c == '\n')
+static int eolprocess(int c, int last, const char *marker,
+ luaL_Buffer *buffer)
+{
+ if (eolcandidate(c)) {
+ if (eolcandidate(last)) {
+ if (c == last) luaL_addstring(buffer, marker);
+ return 0;
+ } else {
+ luaL_addstring(buffer, marker);
+ return c;
+ }
+ } else {
+ luaL_addchar(buffer, (char) c);
+ return 0;
+ }
+}
+
+/*-------------------------------------------------------------------------*\
+* Converts a string to uniform EOL convention.
+* A, n = eol(o, B, marker)
+* A is the converted version of the largest prefix of B that can be
+* converted unambiguously. 'o' is the context returned by the previous
+* call. 'n' is the new context.
+\*-------------------------------------------------------------------------*/
+static int mime_global_eol(lua_State *L)
+{
+ int ctx = (int) luaL_checkinteger(L, 1);
+ size_t isize = 0;
+ const char *input = luaL_optlstring(L, 2, NULL, &isize);
+ const char *last = input + isize;
+ const char *marker = luaL_optstring(L, 3, CRLF);
+ luaL_Buffer buffer;
+ luaL_buffinit(L, &buffer);
+ /* end of input blackhole */
+ if (!input) {
+ lua_pushnil(L);
+ lua_pushnumber(L, 0);
+ return 2;
+ }
+ /* process all input */
+ while (input < last)
+ ctx = eolprocess(*input++, ctx, marker, &buffer);
+ luaL_pushresult(&buffer);
+ lua_pushnumber(L, ctx);
+ return 2;
+}
+
+/*-------------------------------------------------------------------------*\
+* Takes one byte and stuff it if needed.
+\*-------------------------------------------------------------------------*/
+static size_t dot(int c, size_t state, luaL_Buffer *buffer)
+{
+ luaL_addchar(buffer, (char) c);
+ switch (c) {
+ case '\r':
+ return 1;
+ case '\n':
+ return (state == 1)? 2: 0;
+ case '.':
+ if (state == 2)
+ luaL_addchar(buffer, '.');
+ /* Falls through. */
+ default:
+ return 0;
+ }
+}
+
+/*-------------------------------------------------------------------------*\
+* Incrementally applies smtp stuffing to a string
+* A, n = dot(l, D)
+\*-------------------------------------------------------------------------*/
+static int mime_global_dot(lua_State *L)
+{
+ size_t isize = 0, state = (size_t) luaL_checknumber(L, 1);
+ const char *input = luaL_optlstring(L, 2, NULL, &isize);
+ const char *last = input + isize;
+ luaL_Buffer buffer;
+ /* end-of-input blackhole */
+ if (!input) {
+ lua_pushnil(L);
+ lua_pushnumber(L, 2);
+ return 2;
+ }
+ /* process all input */
+ luaL_buffinit(L, &buffer);
+ while (input < last)
+ state = dot(*input++, state, &buffer);
+ luaL_pushresult(&buffer);
+ lua_pushnumber(L, (lua_Number) state);
+ return 2;
+}
+
generated by cgit v1.1-26-g67d0 at 2025-05-20 21:47:43 +0000