libmime 0.1.6 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v1.2.0 2015-10-05
+
+Added support for emojis in header params (eg. filenames)
+
+## v1.1.0 2015-09-24
+
+Updated encoded word encoding with quoted printable, should be more like required in https://tools.ietf.org/html/rfc2047#section-5
+
+## v1.0.0 2015-04-15
+
+Changed versioning scheme to use 1.x instead of 0.x versions. Bumped dependency versions, no actual code changes.
+
+## v0.1.7 2015-01-19
+
+Updated unicode filename handling – only revert to parameter continuation if the value actually includes
+non-ascii characters or is too long. Previously filenames were encoded if they included anything
+besides letters, numbers, dot or space.
+
 ## v0.1.6 2014-10-25
 
 Fixed an issue with `encodeWords` where a trailing space was invalidly included in a word if the word

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Andris Reinman
+Copyright (c) 2014-2015 Andris Reinman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -189,8 +189,8 @@ libmime.buildHeaderParam('filename', 'filename õäöü.txt', 20);
 This can be combined into a properly formatted header:
 
 ```
-Content-disposition: attachment; filename*0*="utf-8''filename%20"
-  filename*1*="%C3%B5%C3%A4%C3%B6"; filename*2*="%C3%BC.txt"
+Content-disposition: attachment; filename*0*=utf-8''filename%20
+  filename*1*=%C3%B5%C3%A4%C3%B6; filename*2*=%C3%BC.txt
 ```
 
 ### MIME Types

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "libmime",
   "description": "Encode and decode quoted printable and base64 strings",
-  "version": "0.1.6",
+  "version": "1.2.0",
   "main": "src/libmime",
   "homepage": "https://github.com/andris9/libmime",
   "repository": {
@@ -19,14 +19,15 @@
     "test": "grunt"
   },
   "dependencies": {
-    "iconv-lite": "^0.4.4",
+    "iconv-lite": "^0.4.13",
     "libbase64": "^0.1.0",
-    "libqp": "^0.1.1"
+    "libqp": "^1.1.0"
   },
   "devDependencies": {
-    "chai": "^1.9.1",
+    "chai": "^3.3.0",
     "grunt": "^0.4.5",
-    "grunt-contrib-jshint": "^0.10.0",
-    "grunt-mocha-test": "^0.11.0"
+    "grunt-contrib-jshint": "^0.11.3",
+    "grunt-mocha-test": "^0.12.7",
+    "mocha": "^2.3.3"
   }
 }

package/src/charset.js

@@ -29,7 +29,7 @@ var charset = module.exports = {
     decode: function(buf, fromCharset) {
         fromCharset = charset.normalizeCharset(fromCharset || 'UTF-8');
 
-        if(/^(us\-)?ascii|utf\-8|7bit$/i.test(fromCharset)){
+        if (/^(us\-)?ascii|utf\-8|7bit$/i.test(fromCharset)) {
             return buf.toString('utf-8');
         }
 

package/src/libmime.js

@@ -48,23 +48,23 @@ var libmime = module.exports = {
 
         return str.
         split(/\r?\n/).
-        // remove soft linebreaks
-        // soft linebreaks are added after space symbols
+            // remove soft linebreaks
+            // soft linebreaks are added after space symbols
         reduce(function(previousValue, currentValue, index) {
-            var body = previousValue;
-            if (delSp) {
-                // delsp adds spaces to text to be able to fold it
-                // these spaces can be removed once the text is unfolded
-                body = body.replace(/[ ]+$/, '');
-            }
-            if (/ $/.test(previousValue) && !/(^|\n)\-\- $/.test(previousValue) || index === 1) {
-                return body + currentValue;
-            } else {
-                return body + '\n' + currentValue;
-            }
-        }).
-        // remove whitespace stuffing
-        // http://tools.ietf.org/html/rfc3676#section-4.4
+                var body = previousValue;
+                if (delSp) {
+                    // delsp adds spaces to text to be able to fold it
+                    // these spaces can be removed once the text is unfolded
+                    body = body.replace(/[ ]+$/, '');
+                }
+                if (/ $/.test(previousValue) && !/(^|\n)\-\- $/.test(previousValue) || index === 1) {
+                    return body + currentValue;
+                } else {
+                    return body + '\n' + currentValue;
+                }
+            }).
+            // remove whitespace stuffing
+            // http://tools.ietf.org/html/rfc3676#section-4.4
         replace(/^ /gm, '');
     },
 
@@ -110,10 +110,15 @@ var libmime = module.exports = {
         }
 
         if (mimeWordEncoding === 'Q') {
-            encodedStr = libqp.encode(data).replace(/[_?\r\n\t"]/g, function(chr) {
+            // https://tools.ietf.org/html/rfc2047#section-5 rule (3)
+            encodedStr = libqp.encode(data).replace(/[^a-z0-9!*+\-\/=]/ig, function(chr) {
                 var ord = chr.charCodeAt(0).toString(16).toUpperCase();
-                return '=' + (ord.length === 1 ? '0' + ord : ord);
-            }).replace(/%20| /g, '_');
+                if (chr === ' ') {
+                    return '_';
+                } else {
+                    return '=' + (ord.length === 1 ? '0' + ord : ord);
+                }
+            });
         } else if (mimeWordEncoding === 'B') {
             encodedStr = typeof data === 'string' ? data : libbase64.encode(data);
             maxLength = Math.max(3, (maxLength - maxLength % 4) / 4 * 3);
@@ -284,17 +289,17 @@ var libmime = module.exports = {
         Object.keys(structured.params || {}).forEach(function(param) {
             // filename might include unicode characters so it is a special case
             var value = structured.params[param];
-            if (param === 'filename' || !libmime.isPlainText(value) || value.length >= 75) {
+            if (!libmime.isPlainText(value) || value.length >= 75) {
                 libmime.buildHeaderParam(param, value, 50).forEach(function(encodedParam) {
                     if (!/[\s"\\;\/=]|^[\-']|'$/.test(encodedParam.value)) {
                         paramsArray.push(encodedParam.key + '=' + encodedParam.value);
                     } else {
-                        paramsArray.push(encodedParam.key + '="' + encodedParam.value + '"');
+                        paramsArray.push(encodedParam.key + '=' + JSON.stringify(encodedParam.value));
                     }
                 });
             } else {
                 if (/[\s'"\\;\/=]|^\-/.test(value)) {
-                    paramsArray.push(param + '="' + value.replace(/(["\\])/g, "\\$1") + '"');
+                    paramsArray.push(param + '=' + JSON.stringify(value));
                 } else {
                     paramsArray.push(param + '=' + value);
                 }
@@ -422,16 +427,16 @@ var libmime = module.exports = {
                         response.params[key].charset +
                         '?Q?' +
                         value.
-                    // fix invalidly encoded chars
+                        // fix invalidly encoded chars
                     replace(/[=\?_\s]/g, function(s) {
-                        var c = s.charCodeAt(0).toString(16);
-                        if (s === ' ') {
-                            return '_';
-                        } else {
-                            return '%' + (c.length < 2 ? '0' : '') + c;
-                        }
-                    }).
-                    // change from urlencoding to percent encoding
+                            var c = s.charCodeAt(0).toString(16);
+                            if (s === ' ') {
+                                return '_';
+                            } else {
+                                return '%' + (c.length < 2 ? '0' : '') + c;
+                            }
+                        }).
+                        // change from urlencoding to percent encoding
                     replace(/%/g, '=') +
                         '?=';
                 } else {
@@ -450,8 +455,8 @@ var libmime = module.exports = {
      * For example
      *      title="unicode string"
      * becomes
-     *     title*0*="utf-8''unicode"
-     *     title*1*="%20string"
+     *     title*0*=utf-8''unicode
+     *     title*1*=%20string
      *
      * @param {String|Buffer} data String to be encoded
      * @param {Number} [maxLength=50] Max length for generated chunks
@@ -461,15 +466,17 @@ var libmime = module.exports = {
     buildHeaderParam: function(key, data, maxLength, fromCharset) {
         var list = [];
         var encodedStr = typeof data === 'string' ? data : libmime.decode(data, fromCharset);
-        var chr;
+        var encodedStrArr;
+        var chr, ord;
         var line;
         var startPos = 0;
         var isEncoded = false;
+        var i, len;
 
         maxLength = maxLength || 50;
 
         // process ascii only text
-        if (/^[\w.\- ]*$/.test(data)) {
+        if (libmime.isPlainText(data)) {
 
             // check if conversion is even needed
             if (encodedStr.length <= maxLength) {
@@ -494,21 +501,39 @@ var libmime = module.exports = {
 
         } else {
 
+            if (/[\uD800-\uDBFF]/.test(encodedStr)) {
+                // string containts surrogate pairs, so normalize it to an array of bytes
+                encodedStrArr = [];
+                for (i = 0, len = encodedStr.length; i < len; i++) {
+                    chr = encodedStr.charAt(i);
+                    ord = chr.charCodeAt(0);
+                    if (ord >= 0xD800 && ord <= 0xDBFF && i < len - 1) {
+                        chr += encodedStr.charAt(i + 1);
+                        encodedStrArr.push(chr);
+                        i++;
+                    } else {
+                        encodedStrArr.push(chr);
+                    }
+                }
+                encodedStr = encodedStrArr;
+            }
+
             // first line includes the charset and language info and needs to be encoded
             // even if it does not contain any unicode characters
             line = 'utf-8\'\'';
             isEncoded = true;
             startPos = 0;
+
             // process text with unicode or special chars
-            for (var i = 0, len = encodedStr.length; i < len; i++) {
+            for (i = 0, len = encodedStr.length; i < len; i++) {
 
                 chr = encodedStr[i];
 
                 if (isEncoded) {
-                    chr = encodeURIComponent(chr);
+                    chr = safeEncodeURIComponent(chr);
                 } else {
                     // try to urlencode current char
-                    chr = chr === ' ' ? chr : encodeURIComponent(chr);
+                    chr = chr === ' ' ? chr : safeEncodeURIComponent(chr);
                     // By default it is not required to encode a line, the need
                     // only appears when the string contains unicode or special chars
                     // in this case we start processing the line over and encode all chars
@@ -516,7 +541,7 @@ var libmime = module.exports = {
                         // Check if it is even possible to add the encoded char to the line
                         // If not, there is no reason to use this line, just push it to the list
                         // and start a new line with the char that needs encoding
-                        if ((encodeURIComponent(line) + chr).length >= maxLength) {
+                        if ((safeEncodeURIComponent(line) + chr).length >= maxLength) {
                             list.push({
                                 line: line,
                                 encoded: isEncoded
@@ -538,7 +563,7 @@ var libmime = module.exports = {
                         line: line,
                         encoded: isEncoded
                     });
-                    line = chr = encodedStr[i] === ' ' ? ' ' : encodeURIComponent(encodedStr[i]);
+                    line = chr = encodedStr[i] === ' ' ? ' ' : safeEncodeURIComponent(encodedStr[i]);
                     if (chr === encodedStr[i]) {
                         isEncoded = false;
                         startPos = i - 1;
@@ -569,6 +594,7 @@ var libmime = module.exports = {
         });
     },
 
+
     /**
      * Returns file extension for a content type string. If no suitable extensions
      * are found, 'bin' is used as the default extension
@@ -720,4 +746,38 @@ function splitMimeEncodedString(str, maxlen) {
     }
 
     return lines;
+}
+
+function encodeURICharComponent(chr) {
+    var i, len, ord;
+    var res = '';
+
+    ord = chr.charCodeAt(0).toString(16).toUpperCase();
+    if (ord.length % 2) {
+        ord = '0' + ord;
+    }
+    if (ord.length > 2) {
+        for (i = 0, len = ord.length / 2; i < len; i++) {
+            res += '%' + ord.substr(i, 2);
+        }
+    } else {
+        res += '%' + ord;
+    }
+
+    return res;
+}
+
+function safeEncodeURIComponent(str) {
+    str = (str || '').toString();
+
+    try {
+        // might throw if we try to encode invalid sequences, eg. partial emoji
+        str = encodeURIComponent(str);
+    } catch (E) {
+        // should never run
+        return str.replace(/[^\x00-\x1F *'()<>@,;:\\"\[\]?=\u007F-\uFFFF]+/g, '');
+    }
+
+    // ensure chars that are not handled by encodeURICompent are converted as well
+    return str.replace(/[\x00-\x1F *'()<>@,;:\\"\[\]?=\u007F-\uFFFF]/g, encodeURICharComponent);
 }