diff --git a/lib/tutf8e/CMakeLists.txt b/lib/tutf8e/CMakeLists.txt
index fcf2012af4e..35cbe01adab 100644
--- a/lib/tutf8e/CMakeLists.txt
+++ b/lib/tutf8e/CMakeLists.txt
@@ -14,4 +14,4 @@ set_property(TARGET tutf8e PROPERTY C_EXTENSIONS OFF)
 add_executable(tutf8e-test test/test.c)
 target_link_libraries(tutf8e-test tutf8e)
 set_property(TARGET tutf8e-test PROPERTY C_STANDARD 99)
-set_property(TARGET tutf8e-test PROPERTY C_EXTENSIONS OFF)
+set_property(TARGET tutf8e-test PROPERTY C_EXTENSIONS ON)
diff --git a/lib/tutf8e/codegen.py b/lib/tutf8e/codegen.py
index 27af1c81bd0..8d7c2c635a9 100755
--- a/lib/tutf8e/codegen.py
+++ b/lib/tutf8e/codegen.py
@@ -19,42 +19,107 @@
 #include <stddef.h>  /* size_t */
 #include <stdint.h>  /* uint16_t */
 
-/* Internal API */
+/*************** Internal API ***************/
 
-extern int tutf8e_string_length(const uint16_t *table, const char *i, size_t *ilen, size_t *olen);
-extern int tutf8e_string_encode(const uint16_t *table, const char *i, char *o, size_t *olen);
+/* NUL-terminated C-string API */
 
-extern int tutf8e_buffer_length(const uint16_t *table, const char *i, size_t ilen, size_t *olen);
-extern int tutf8e_buffer_encode(const uint16_t *table, const char *i, size_t ilen, char *o, size_t *olen);
+extern int tutf8e_string_length(const uint16_t *table, const char *input, const char *invalid, size_t *input_length, size_t *output_length);
+extern int tutf8e_string_encode(const uint16_t *table, const char *input, const char *invalid, char *output, size_t *output_length);
 
-/* Generic API */
+/* Known-length buffer API */
+
+extern int tutf8e_buffer_length(const uint16_t *table, const char *input, size_t input_length, const char *invalid, size_t *output_length);
+extern int tutf8e_buffer_encode(const uint16_t *table, const char *input, size_t input_length, const char *invalid, char *output, size_t *output_length);
+
+/*************** Public API ***************/
+
+/* Opaque handle type */
 
 typedef void *TUTF8encoder;
 
+/* Query encoder by name */
+
 extern TUTF8encoder tutf8e_encoder(const char *encoding);
 
 #define TUTF8E_OK      0 /* Success                    */
 #define TUTF8E_INVALID 1 /* Invalid input character    */
 #define TUTF8E_TOOLONG 2 /* Insufficient output buffer */
 
-static inline int tutf8e_encoder_string_length(const TUTF8encoder encoder, const char *i, size_t *ilen, size_t *olen)
+/*
+ * tutf8e_encoder_string_length
+ *
+ * Determine the length of input and UTF8 encoded output of NUL-terminated string
+ * Performance: single pass O(n)
+ *
+ * output NUL terminator not counted
+ *
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_string_length(const TUTF8encoder encoder, const char *input, const char *invalid, size_t *input_length, size_t *output_length)
 {
-  return tutf8e_string_length((const uint16_t *) encoder, i, ilen, olen);
+  return tutf8e_string_length((const uint16_t *) encoder, input, invalid, input_length, output_length);
 }
 
-static inline int tutf8e_encoder_string_encode(const TUTF8encoder encoder, const char *i, char *o, size_t *olen)
+/*
+ * tutf8e_encoder_string_encode
+ *
+ * UTF8 encode NUL-terminated string
+ * Performance: two pass O(n)
+ *
+ * output string is NUL terminated
+ * output_length is output buffer size for input
+ * output_length is encoded length for output, including NUL
+ *
+ * - TUTF8E_TOOLONG if output buffer insuficient
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_string_encode(const TUTF8encoder encoder, const char *input, const char *invalid, char *output, size_t *output_length)
 {
-  return tutf8e_string_encode((const uint16_t *) encoder, i, o, olen);
+  return tutf8e_string_encode((const uint16_t *) encoder, input, invalid, output, output_length);
 }
 
-static inline int tutf8e_encoder_buffer_length(const TUTF8encoder encoder, const char *i, size_t ilen, size_t *length)
+/* Known-length buffer API */
+
+/*
+ * tutf8e_encoder_buffer_length
+ *
+ * Determine the length of input and UTF8 encoded output of string
+ * Performance: single pass O(n)
+ *
+ * output NUL terminator not counted
+ *
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_buffer_length(const TUTF8encoder encoder, const char *input, const char *invalid, size_t input_length, size_t *length)
 {
-  return tutf8e_buffer_length((const uint16_t *) encoder, i, ilen, length);
+  return tutf8e_buffer_length((const uint16_t *) encoder, input, input_length, invalid, length);
 }
 
-static inline int tutf8e_encoder_buffer_encode(const TUTF8encoder encoder, const char *i, size_t ilen, char *o, size_t *olen)
+/*
+ * tutf8e_encoder_buffer_encode
+ *
+ * UTF8 encode string
+ * Performance: two pass O(n)
+ *
+ * output string is not NUL terminated
+ *
+ * output_length is output buffer size for input
+ * output_length is encoded length for output
+ *
+ * - TUTF8E_TOOLONG if output buffer insuficient
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_buffer_encode(const TUTF8encoder encoder, const char *input, size_t input_length, const char *invalid, char *output, size_t *output_length)
 {
-  return tutf8e_buffer_encode((const uint16_t *) encoder, i, ilen, o, olen);
+  return tutf8e_buffer_encode((const uint16_t *) encoder, input, input_length, invalid, output, output_length);
 }
 
 ''')
@@ -74,63 +139,65 @@
 
 #include <string.h>
 
-/* Determine the input length and UTF8 encoded length of NUL-terminated input string */
-/* return TUTF8E_INVALID if input character is not convertable                       */
-/* return TUTF8E_OK for success                                                      */
-
-int tutf8e_string_length(const uint16_t *table, const char *input, size_t *ilen, size_t *olen)
+int tutf8e_string_length(const uint16_t *table, const char *input, const char *invalid, size_t *input_length, size_t *output_length)
 {
+  const size_t invalid_length = invalid ? strlen(invalid) : 0;
+
   const unsigned char *i;
-  for (i = (const unsigned char *) input; *i; ++i, (*ilen)++) {
+  for (i = (const unsigned char *) input; *i; ++i, (*input_length)++) {
     const uint16_t c = table[*i];
     if (c<0x80) {
-      *olen += 1;
+      *output_length += 1;
       continue;
     }
     if (c<0x800) {
-      *olen += 2;
+      *output_length += 2;
       continue;
     }
     if (c<0xffff) {
-      *olen += 3;
+      *output_length += 3;
       continue;
     }
-    return TUTF8E_INVALID;
+    if (invalid) {
+      *output_length += invalid_length;
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
   }
   return TUTF8E_OK;
 }
 
-/* UTF8 encode the given input string and table                */
-/* olen input is output buffer size, output is encoded length  */
-/* return TUTF8E_TOOLONG if output buffer insuficient          */
-/* return TUTF8E_INVALID if input character is not convertable */
-/* return TUTF8E_OK for success                                */
-
-int tutf8e_string_encode(const uint16_t *table, const char *i, char *o, size_t *olen)
+int tutf8e_string_encode(const uint16_t *table, const char *input, const char *invalid, char *output, size_t *output_length)
 {
   int ret;
-  size_t ilen = 0;
-  size_t length = 0;
-  if (!(ret = tutf8e_string_length(table, i, &ilen, &length)))
+  size_t input_length = 0;
+  size_t encoded_length = 0;
+  if (!(ret = tutf8e_string_length(table, input, invalid, &input_length, &encoded_length)))
   {
-    if (length+1 > *olen) return TUTF8E_TOOLONG;
-    if (!(ret = tutf8e_buffer_encode(table, i, ilen, o, olen)))
+    if (encoded_length+1 > *output_length) return TUTF8E_TOOLONG;
+    if (!(ret = tutf8e_buffer_encode(table, input, input_length, invalid, output, output_length)))
     {
-      o[length] = 0;
+      output[encoded_length] = 0;
       return TUTF8E_OK;
     }
   }
   return ret;
 }
 
-/* Determine the length of the UTF8 encoding of given input string and table */
-/* return TUTF8E_INVALID if input character is not convertable               */
-/* return TUTF8E_OK for success                                              */
-
-int tutf8e_buffer_length(const uint16_t *table, const char *input, size_t ilen, size_t *length)
+int tutf8e_buffer_length
+(
+  const uint16_t *table,
+  const char *input,
+  size_t input_length,
+  const char *invalid,
+  size_t *length
+)
 {
+  const size_t invalid_length = invalid ? strlen(invalid) : 0;
+
   const unsigned char *i;
-  for (i = (const unsigned char *) input; ilen; ++i, --ilen) {
+  for (i = (const unsigned char *) input; input_length; ++i, --input_length) {
     const uint16_t c = table[*i];
     if (c<0x80) {
       ++*length;
@@ -144,23 +211,32 @@
       *length += 3;
       continue;
     }
-    return TUTF8E_INVALID;
+    if (invalid) {
+      *length += invalid_length;
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
   }
   return TUTF8E_OK;
 }
 
-/* UTF8 encode the given input string and table                */
-/* olen input is output buffer size, output is encoded length  */
-/* return TUTF8E_TOOLONG if output buffer insuficient          */
-/* return TUTF8E_INVALID if input character is not convertable */
-/* return TUTF8E_OK for success                                */
-
-int tutf8e_buffer_encode(const uint16_t *table, const char *input, size_t ilen, char *output, size_t *olen)
+int tutf8e_buffer_encode
+(
+  const uint16_t *table,
+  const char *input,
+  size_t input_length,
+  const char *invalid,
+  char *output,
+  size_t *output_length
+)
 {
-  size_t left = *olen;
+  size_t invalid_length = invalid ? strlen(invalid) : 0;
+
+  size_t left = *output_length;
   unsigned char *o = (unsigned char *) output;
   const unsigned char *i;
-  for (i = (const unsigned char *) input; ilen; ++i, --ilen) {
+  for (i = (const unsigned char *) input; input_length; ++i, --input_length) {
     const uint16_t c = table[*i];
     if (c<0x80) {
       if (left<1) return TUTF8E_TOOLONG;
@@ -183,9 +259,20 @@
       left -= 3;
       continue;
     }
-    return TUTF8E_INVALID;
+    if (invalid)
+    {
+      if (left<invalid_length) return TUTF8E_TOOLONG;
+      if (invalid_length) {
+        memcpy(o, invalid, invalid_length);
+        o += invalid_length;
+        left -= invalid_length;
+      }
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
   }
-  *olen -= left;
+  *output_length -= left;
   return TUTF8E_OK;
 }
 ''')
@@ -245,30 +332,30 @@
 '''%(name.upper(), name.upper()))
 
     include.write('''
-static inline int tutf8e_%s_string_length(const char *i, size_t *ilen, size_t *olen)
+static inline int tutf8e_%s_string_length(const char *input, const char *invalid, size_t *input_length, size_t *output_length)
 {
-  return tutf8e_encoder_string_length(tutf8e_encoder_%s, i, ilen, olen);
+  return tutf8e_encoder_string_length(tutf8e_encoder_%s, input, invalid, input_length, output_length);
 }
 '''%(name, name))
 
     include.write('''
-static inline int tutf8e_%s_string_encode(const char *i, char *o, size_t *olen)
+static inline int tutf8e_%s_string_encode(const char *input, const char *invalid, char *output, size_t *output_length)
 {
-  return tutf8e_encoder_string_encode(tutf8e_encoder_%s, i, o, olen);
+  return tutf8e_encoder_string_encode(tutf8e_encoder_%s, input, invalid, output, output_length);
 }
 '''%(name, name))
 
     include.write('''
-static inline int tutf8e_%s_buffer_length(const char *i, size_t ilen, size_t *length)
+static inline int tutf8e_%s_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
 {
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_%s, i, ilen, length);
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_%s, input, input_length, invalid, length);
 }
 '''%(name, name))
 
     include.write('''
-static inline int tutf8e_%s_buffer_encode(const char *i, size_t ilen, char *o, size_t *olen)
+static inline int tutf8e_%s_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
 {
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_%s, i, ilen, o, olen);
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_%s, input, input_length, invalid, output, output_length);
 }
 '''%(name, name))
 
@@ -313,7 +400,8 @@
   test.write('  int pass = 0;\n')
   test.write('  int fail = 0;\n')
   test.write('  int ret;\n')
-  test.write('  size_t ilen, olen;\n')
+  test.write('  char *copy;\n')
+  test.write('  size_t input_length, output_length;\n')
   test.write('  char buffer[1024];\n')
   # test.write('  char *encoded;\n')
   test.write('\n')
@@ -335,12 +423,12 @@
         test.write('    %s,\n'%(', '.join([ '0x%02x'%(j) for j in data[i:i+24]])))
       test.write('  };\n')
 
-  test.write('\n  /* string encode to UTF8 */\n')
+  test.write('\n  /* string encode to UTF8, error on invalid input */\n')
   for i in tests:
     if i[1] in encodings:
       name = i[1].replace('-', '_').lower()
-      test.write('  olen = sizeof(buffer);\n')
-      test.write('  ret = tutf8e_encoder_string_encode(tutf8e_encoder_%s, %s, buffer, &olen);\n'%(name, i[0]))
+      test.write('  output_length = sizeof(buffer);\n')
+      test.write('  ret = tutf8e_encoder_string_encode(tutf8e_encoder_%s, %s, NULL, buffer, &output_length);\n'%(name, i[0]))
       test.write('  if (!ret && !strcmp(buffer, %sUTF8)) {\n'%(i[0]))
       test.write('    printf("%s\\n", buffer);\n')
       test.write('    pass++;\n')
@@ -350,19 +438,57 @@
       test.write('  }\n')
       test.write('\n')
 
-  test.write('\n  /* buffer encode to UTF8 */\n')
+  test.write('\n  /* buffer encode to UTF8, error on invalid input */\n')
   for i in tests:
     if i[1] in encodings:
       name = i[1].replace('-', '_').lower()
-      test.write('  ilen = strlen(%s);\n'%(i[0]))
-      test.write('  olen = sizeof(buffer);\n')
-      test.write('  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_%s, %s, ilen, buffer, &olen);\n'%(name, i[0]))
-      test.write('  if (!ret && (olen+1)==sizeof(%sUTF8) && !strncmp(buffer, %sUTF8, olen)) {\n'%(i[0], i[0]))
+      test.write('  input_length = strlen(%s);\n'%(i[0]))
+      test.write('  output_length = sizeof(buffer);\n')
+      test.write('  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_%s, %s, input_length, NULL, buffer, &output_length);\n'%(name, i[0]))
+      test.write('  if (!ret && (output_length+1)==sizeof(%sUTF8) && !strncmp(buffer, %sUTF8, output_length)) {\n'%(i[0], i[0]))
+      test.write('    pass++;\n')
+      test.write('  } else {\n')
+      test.write('    printf("Failed to encode %s test\\n");\n'%(i[0]))
+      test.write('    fail++;\n')
+      test.write('  }\n')
+      test.write('\n')
+
+  test.write('\n  /* string encode to UTF8, first input character invalid -> ? */\n')
+  for i in tests:
+    if i[1] in ['iso-8859-6', 'iso-8859-7', 'iso-8859-11']:
+      name = i[1].replace('-', '_').lower()
+      test.write('  output_length = sizeof(buffer);\n')
+      test.write('  copy = strdup(%s);\n'%(i[0]))
+      test.write('  copy[0] = 255;\n')
+      test.write('  buffer[0] = 255;\n')
+      test.write('  ret = tutf8e_encoder_string_encode(tutf8e_encoder_%s, copy, "?", buffer, &output_length);\n'%(name))
+      test.write('  if (!ret && buffer[0]==\'?\') {\n')
+      test.write('    printf("%s\\n", buffer);\n')
+      test.write('    pass++;\n')
+      test.write('  } else {\n')
+      test.write('    printf("Failed to encode %s test\\n");\n'%(i[0]))
+      test.write('    fail++;\n')
+      test.write('  }\n')
+      test.write('  free(copy);\n')
+      test.write('\n')
+
+  test.write('\n  /* string encode to UTF8, first input character invalid -> [INVALID] */\n')
+  for i in tests:
+    if i[1] in ['iso-8859-6', 'iso-8859-7', 'iso-8859-11']:
+      name = i[1].replace('-', '_').lower()
+      test.write('  output_length = sizeof(buffer);\n')
+      test.write('  copy = strdup(%s);\n'%(i[0]))
+      test.write('  copy[0] = 255;\n')
+      test.write('  buffer[0] = 255;\n')
+      test.write('  ret = tutf8e_encoder_string_encode(tutf8e_encoder_%s, copy, "[INVALID]", buffer, &output_length);\n'%(name))
+      test.write('  if (!ret && !strncmp(buffer, "[INVALID]", 9)) {\n')
+      test.write('    printf("%s\\n", buffer);\n')
       test.write('    pass++;\n')
       test.write('  } else {\n')
       test.write('    printf("Failed to encode %s test\\n");\n'%(i[0]))
       test.write('    fail++;\n')
       test.write('  }\n')
+      test.write('  free(copy);\n')
       test.write('\n')
 
   test.write('  printf("%d passed, %d failed tests\\n", pass, fail);\n')
diff --git a/lib/tutf8e/include/tutf8e.h b/lib/tutf8e/include/tutf8e.h
index 7c0befbd74a..478f514b572 100644
--- a/lib/tutf8e/include/tutf8e.h
+++ b/lib/tutf8e/include/tutf8e.h
@@ -5,42 +5,107 @@
 #include <stddef.h>  /* size_t */
 #include <stdint.h>  /* uint16_t */
 
-/* Internal API */
+/*************** Internal API ***************/
 
-extern int tutf8e_string_length(const uint16_t *table, const char *i, size_t *ilen, size_t *olen);
-extern int tutf8e_string_encode(const uint16_t *table, const char *i, char *o, size_t *olen);
+/* NUL-terminated C-string API */
 
-extern int tutf8e_buffer_length(const uint16_t *table, const char *i, size_t ilen, size_t *olen);
-extern int tutf8e_buffer_encode(const uint16_t *table, const char *i, size_t ilen, char *o, size_t *olen);
+extern int tutf8e_string_length(const uint16_t *table, const char *input, const char *invalid, size_t *input_length, size_t *output_length);
+extern int tutf8e_string_encode(const uint16_t *table, const char *input, const char *invalid, char *output, size_t *output_length);
 
-/* Generic API */
+/* Known-length buffer API */
+
+extern int tutf8e_buffer_length(const uint16_t *table, const char *input, size_t input_length, const char *invalid, size_t *output_length);
+extern int tutf8e_buffer_encode(const uint16_t *table, const char *input, size_t input_length, const char *invalid, char *output, size_t *output_length);
+
+/*************** Public API ***************/
+
+/* Opaque handle type */
 
 typedef void *TUTF8encoder;
 
+/* Query encoder by name */
+
 extern TUTF8encoder tutf8e_encoder(const char *encoding);
 
 #define TUTF8E_OK      0 /* Success                    */
 #define TUTF8E_INVALID 1 /* Invalid input character    */
 #define TUTF8E_TOOLONG 2 /* Insufficient output buffer */
 
-static inline int tutf8e_encoder_string_length(const TUTF8encoder encoder, const char *i, size_t *ilen, size_t *olen)
+/*
+ * tutf8e_encoder_string_length
+ *
+ * Determine the length of input and UTF8 encoded output of NUL-terminated string
+ * Performance: single pass O(n)
+ *
+ * output NUL terminator not counted
+ *
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_string_length(const TUTF8encoder encoder, const char *input, const char *invalid, size_t *input_length, size_t *output_length)
 {
-  return tutf8e_string_length((const uint16_t *) encoder, i, ilen, olen);
+  return tutf8e_string_length((const uint16_t *) encoder, input, invalid, input_length, output_length);
 }
 
-static inline int tutf8e_encoder_string_encode(const TUTF8encoder encoder, const char *i, char *o, size_t *olen)
+/*
+ * tutf8e_encoder_string_encode
+ *
+ * UTF8 encode NUL-terminated string
+ * Performance: two pass O(n)
+ *
+ * output string is NUL terminated
+ * output_length is output buffer size for input
+ * output_length is encoded length for output, including NUL
+ *
+ * - TUTF8E_TOOLONG if output buffer insuficient
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_string_encode(const TUTF8encoder encoder, const char *input, const char *invalid, char *output, size_t *output_length)
 {
-  return tutf8e_string_encode((const uint16_t *) encoder, i, o, olen);
+  return tutf8e_string_encode((const uint16_t *) encoder, input, invalid, output, output_length);
 }
 
-static inline int tutf8e_encoder_buffer_length(const TUTF8encoder encoder, const char *i, size_t ilen, size_t *length)
+/* Known-length buffer API */
+
+/*
+ * tutf8e_encoder_buffer_length
+ *
+ * Determine the length of input and UTF8 encoded output of string
+ * Performance: single pass O(n)
+ *
+ * output NUL terminator not counted
+ *
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_buffer_length(const TUTF8encoder encoder, const char *input, const char *invalid, size_t input_length, size_t *length)
 {
-  return tutf8e_buffer_length((const uint16_t *) encoder, i, ilen, length);
+  return tutf8e_buffer_length((const uint16_t *) encoder, input, input_length, invalid, length);
 }
 
-static inline int tutf8e_encoder_buffer_encode(const TUTF8encoder encoder, const char *i, size_t ilen, char *o, size_t *olen)
+/*
+ * tutf8e_encoder_buffer_encode
+ *
+ * UTF8 encode string
+ * Performance: two pass O(n)
+ *
+ * output string is not NUL terminated
+ *
+ * output_length is output buffer size for input
+ * output_length is encoded length for output
+ *
+ * - TUTF8E_TOOLONG if output buffer insuficient
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_buffer_encode(const TUTF8encoder encoder, const char *input, size_t input_length, const char *invalid, char *output, size_t *output_length)
 {
-  return tutf8e_buffer_encode((const uint16_t *) encoder, i, ilen, o, olen);
+  return tutf8e_buffer_encode((const uint16_t *) encoder, input, input_length, invalid, output, output_length);
 }
 
 /* Supported encoders */
diff --git a/lib/tutf8e/src/tutf8e.c b/lib/tutf8e/src/tutf8e.c
index 70d4602b79d..9e169becdb1 100644
--- a/lib/tutf8e/src/tutf8e.c
+++ b/lib/tutf8e/src/tutf8e.c
@@ -3,63 +3,65 @@
 
 #include <string.h>
 
-/* Determine the input length and UTF8 encoded length of NUL-terminated input string */
-/* return TUTF8E_INVALID if input character is not convertable                       */
-/* return TUTF8E_OK for success                                                      */
-
-int tutf8e_string_length(const uint16_t *table, const char *input, size_t *ilen, size_t *olen)
+int tutf8e_string_length(const uint16_t *table, const char *input, const char *invalid, size_t *input_length, size_t *output_length)
 {
+  const size_t invalid_length = invalid ? strlen(invalid) : 0;
+
   const unsigned char *i;
-  for (i = (const unsigned char *) input; *i; ++i, (*ilen)++) {
+  for (i = (const unsigned char *) input; *i; ++i, (*input_length)++) {
     const uint16_t c = table[*i];
     if (c<0x80) {
-      *olen += 1;
+      *output_length += 1;
       continue;
     }
     if (c<0x800) {
-      *olen += 2;
+      *output_length += 2;
       continue;
     }
     if (c<0xffff) {
-      *olen += 3;
+      *output_length += 3;
       continue;
     }
-    return TUTF8E_INVALID;
+    if (invalid) {
+      *output_length += invalid_length;
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
   }
   return TUTF8E_OK;
 }
 
-/* UTF8 encode the given input string and table                */
-/* olen input is output buffer size, output is encoded length  */
-/* return TUTF8E_TOOLONG if output buffer insuficient          */
-/* return TUTF8E_INVALID if input character is not convertable */
-/* return TUTF8E_OK for success                                */
-
-int tutf8e_string_encode(const uint16_t *table, const char *i, char *o, size_t *olen)
+int tutf8e_string_encode(const uint16_t *table, const char *input, const char *invalid, char *output, size_t *output_length)
 {
   int ret;
-  size_t ilen = 0;
-  size_t length = 0;
-  if (!(ret = tutf8e_string_length(table, i, &ilen, &length)))
+  size_t input_length = 0;
+  size_t encoded_length = 0;
+  if (!(ret = tutf8e_string_length(table, input, invalid, &input_length, &encoded_length)))
   {
-    if (length+1 > *olen) return TUTF8E_TOOLONG;
-    if (!(ret = tutf8e_buffer_encode(table, i, ilen, o, olen)))
+    if (encoded_length+1 > *output_length) return TUTF8E_TOOLONG;
+    if (!(ret = tutf8e_buffer_encode(table, input, input_length, invalid, output, output_length)))
     {
-      o[length] = 0;
+      output[encoded_length] = 0;
       return TUTF8E_OK;
     }
   }
   return ret;
 }
 
-/* Determine the length of the UTF8 encoding of given input string and table */
-/* return TUTF8E_INVALID if input character is not convertable               */
-/* return TUTF8E_OK for success                                              */
-
-int tutf8e_buffer_length(const uint16_t *table, const char *input, size_t ilen, size_t *length)
+int tutf8e_buffer_length
+(
+  const uint16_t *table,
+  const char *input,
+  size_t input_length,
+  const char *invalid,
+  size_t *length
+)
 {
+  const size_t invalid_length = invalid ? strlen(invalid) : 0;
+
   const unsigned char *i;
-  for (i = (const unsigned char *) input; ilen; ++i, --ilen) {
+  for (i = (const unsigned char *) input; input_length; ++i, --input_length) {
     const uint16_t c = table[*i];
     if (c<0x80) {
       ++*length;
@@ -73,23 +75,32 @@ int tutf8e_buffer_length(const uint16_t *table, const char *input, size_t ilen,
       *length += 3;
       continue;
     }
-    return TUTF8E_INVALID;
+    if (invalid) {
+      *length += invalid_length;
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
   }
   return TUTF8E_OK;
 }
 
-/* UTF8 encode the given input string and table                */
-/* olen input is output buffer size, output is encoded length  */
-/* return TUTF8E_TOOLONG if output buffer insuficient          */
-/* return TUTF8E_INVALID if input character is not convertable */
-/* return TUTF8E_OK for success                                */
-
-int tutf8e_buffer_encode(const uint16_t *table, const char *input, size_t ilen, char *output, size_t *olen)
+int tutf8e_buffer_encode
+(
+  const uint16_t *table,
+  const char *input,
+  size_t input_length,
+  const char *invalid,
+  char *output,
+  size_t *output_length
+)
 {
-  size_t left = *olen;
+  size_t invalid_length = invalid ? strlen(invalid) : 0;
+
+  size_t left = *output_length;
   unsigned char *o = (unsigned char *) output;
   const unsigned char *i;
-  for (i = (const unsigned char *) input; ilen; ++i, --ilen) {
+  for (i = (const unsigned char *) input; input_length; ++i, --input_length) {
     const uint16_t c = table[*i];
     if (c<0x80) {
       if (left<1) return TUTF8E_TOOLONG;
@@ -112,9 +123,20 @@ int tutf8e_buffer_encode(const uint16_t *table, const char *input, size_t ilen,
       left -= 3;
       continue;
     }
-    return TUTF8E_INVALID;
+    if (invalid)
+    {
+      if (left<invalid_length) return TUTF8E_TOOLONG;
+      if (invalid_length) {
+        memcpy(o, invalid, invalid_length);
+        o += invalid_length;
+        left -= invalid_length;
+      }
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
   }
-  *olen -= left;
+  *output_length -= left;
   return TUTF8E_OK;
 }
 
diff --git a/lib/tutf8e/test/test.c b/lib/tutf8e/test/test.c
index 43c1e3bde88..618cb1f7997 100644
--- a/lib/tutf8e/test/test.c
+++ b/lib/tutf8e/test/test.c
@@ -9,7 +9,8 @@ int main(int argc, char *argv[])
   int pass = 0;
   int fail = 0;
   int ret;
-  size_t ilen, olen;
+  char *copy;
+  size_t input_length, output_length;
   char buffer[1024];
 
   static const char english[] = {
@@ -166,9 +167,9 @@ int main(int argc, char *argv[])
     0x21, 0x00,
   };
 
-  /* string encode to UTF8 */
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, english, buffer, &olen);
+  /* string encode to UTF8, error on invalid input */
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, english, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, englishUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -177,8 +178,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, finnish, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, finnish, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, finnishUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -187,8 +188,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_2, czech, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_2, czech, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, czechUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -197,8 +198,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_3, turkish, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_3, turkish, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, turkishUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -207,8 +208,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_4, estonian, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_4, estonian, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, estonianUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -217,8 +218,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_5, russian, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_5, russian, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, russianUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -227,8 +228,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_7, greek, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_7, greek, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, greekUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -237,8 +238,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_8, hebrew, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_8, hebrew, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, hebrewUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -247,8 +248,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_9, turkish2, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_9, turkish2, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, turkish2UTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -257,8 +258,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_10, swedish, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_10, swedish, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, swedishUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -267,8 +268,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, thai, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, thai, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, thaiUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -277,8 +278,8 @@ int main(int argc, char *argv[])
     fail++;
   }
 
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_13, polish, buffer, &olen);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_13, polish, NULL, buffer, &output_length);
   if (!ret && !strcmp(buffer, polishUTF8)) {
     printf("%s\n", buffer);
     pass++;
@@ -288,126 +289,186 @@ int main(int argc, char *argv[])
   }
 
 
-  /* buffer encode to UTF8 */
-  ilen = strlen(english);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, english, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(englishUTF8) && !strncmp(buffer, englishUTF8, olen)) {
+  /* buffer encode to UTF8, error on invalid input */
+  input_length = strlen(english);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, english, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(englishUTF8) && !strncmp(buffer, englishUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode english test\n");
     fail++;
   }
 
-  ilen = strlen(finnish);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, finnish, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(finnishUTF8) && !strncmp(buffer, finnishUTF8, olen)) {
+  input_length = strlen(finnish);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, finnish, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(finnishUTF8) && !strncmp(buffer, finnishUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode finnish test\n");
     fail++;
   }
 
-  ilen = strlen(czech);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_2, czech, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(czechUTF8) && !strncmp(buffer, czechUTF8, olen)) {
+  input_length = strlen(czech);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_2, czech, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(czechUTF8) && !strncmp(buffer, czechUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode czech test\n");
     fail++;
   }
 
-  ilen = strlen(turkish);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_3, turkish, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(turkishUTF8) && !strncmp(buffer, turkishUTF8, olen)) {
+  input_length = strlen(turkish);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_3, turkish, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(turkishUTF8) && !strncmp(buffer, turkishUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode turkish test\n");
     fail++;
   }
 
-  ilen = strlen(estonian);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_4, estonian, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(estonianUTF8) && !strncmp(buffer, estonianUTF8, olen)) {
+  input_length = strlen(estonian);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_4, estonian, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(estonianUTF8) && !strncmp(buffer, estonianUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode estonian test\n");
     fail++;
   }
 
-  ilen = strlen(russian);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_5, russian, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(russianUTF8) && !strncmp(buffer, russianUTF8, olen)) {
+  input_length = strlen(russian);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_5, russian, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(russianUTF8) && !strncmp(buffer, russianUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode russian test\n");
     fail++;
   }
 
-  ilen = strlen(greek);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_7, greek, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(greekUTF8) && !strncmp(buffer, greekUTF8, olen)) {
+  input_length = strlen(greek);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_7, greek, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(greekUTF8) && !strncmp(buffer, greekUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode greek test\n");
     fail++;
   }
 
-  ilen = strlen(hebrew);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_8, hebrew, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(hebrewUTF8) && !strncmp(buffer, hebrewUTF8, olen)) {
+  input_length = strlen(hebrew);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_8, hebrew, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(hebrewUTF8) && !strncmp(buffer, hebrewUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode hebrew test\n");
     fail++;
   }
 
-  ilen = strlen(turkish2);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_9, turkish2, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(turkish2UTF8) && !strncmp(buffer, turkish2UTF8, olen)) {
+  input_length = strlen(turkish2);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_9, turkish2, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(turkish2UTF8) && !strncmp(buffer, turkish2UTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode turkish2 test\n");
     fail++;
   }
 
-  ilen = strlen(swedish);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_10, swedish, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(swedishUTF8) && !strncmp(buffer, swedishUTF8, olen)) {
+  input_length = strlen(swedish);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_10, swedish, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(swedishUTF8) && !strncmp(buffer, swedishUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode swedish test\n");
     fail++;
   }
 
-  ilen = strlen(thai);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_11, thai, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(thaiUTF8) && !strncmp(buffer, thaiUTF8, olen)) {
+  input_length = strlen(thai);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_11, thai, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(thaiUTF8) && !strncmp(buffer, thaiUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode thai test\n");
     fail++;
   }
 
-  ilen = strlen(polish);
-  olen = sizeof(buffer);
-  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_13, polish, ilen, buffer, &olen);
-  if (!ret && (olen+1)==sizeof(polishUTF8) && !strncmp(buffer, polishUTF8, olen)) {
+  input_length = strlen(polish);
+  output_length = sizeof(buffer);
+  ret = tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_13, polish, input_length, NULL, buffer, &output_length);
+  if (!ret && (output_length+1)==sizeof(polishUTF8) && !strncmp(buffer, polishUTF8, output_length)) {
     pass++;
   } else {
     printf("Failed to encode polish test\n");
     fail++;
   }
 
+
+  /* string encode to UTF8, first input character invalid -> ? */
+  output_length = sizeof(buffer);
+  copy = strdup(greek);
+  copy[0] = 255;
+  buffer[0] = 255;
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_7, copy, "?", buffer, &output_length);
+  if (!ret && buffer[0]=='?') {
+    printf("%s\n", buffer);
+    pass++;
+  } else {
+    printf("Failed to encode greek test\n");
+    fail++;
+  }
+  free(copy);
+
+  output_length = sizeof(buffer);
+  copy = strdup(thai);
+  copy[0] = 255;
+  buffer[0] = 255;
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, copy, "?", buffer, &output_length);
+  if (!ret && buffer[0]=='?') {
+    printf("%s\n", buffer);
+    pass++;
+  } else {
+    printf("Failed to encode thai test\n");
+    fail++;
+  }
+  free(copy);
+
+
+  /* string encode to UTF8, first input character invalid -> [INVALID] */
+  output_length = sizeof(buffer);
+  copy = strdup(greek);
+  copy[0] = 255;
+  buffer[0] = 255;
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_7, copy, "[INVALID]", buffer, &output_length);
+  if (!ret && !strncmp(buffer, "[INVALID]", 9)) {
+    printf("%s\n", buffer);
+    pass++;
+  } else {
+    printf("Failed to encode greek test\n");
+    fail++;
+  }
+  free(copy);
+
+  output_length = sizeof(buffer);
+  copy = strdup(thai);
+  copy[0] = 255;
+  buffer[0] = 255;
+  ret = tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, copy, "[INVALID]", buffer, &output_length);
+  if (!ret && !strncmp(buffer, "[INVALID]", 9)) {
+    printf("%s\n", buffer);
+    pass++;
+  } else {
+    printf("Failed to encode thai test\n");
+    fail++;
+  }
+  free(copy);
+
   printf("%d passed, %d failed tests\n", pass, fail);
 }