* fix the url handling of '&'; it's a bit hairy because of the
[modest] / src / modest-text-utils.c
index 7d2806e..3a89582 100644 (file)
@@ -42,7 +42,7 @@
 #include <modest-tny-platform-factory.h>
 #include <modest-text-utils.h>
 #include <modest-runtime.h>
-
+#include <ctype.h>
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
  */
 #define HYPERLINKIFY_MAX_LENGTH (1024*50)
 
+
+/*
+ * we mark the ampersand with \007 when converting text->html
+ * because after text->html we do hyperlink detecting, which
+ * could be screwed up by the ampersand
+ */
+#define MARK_AMP '\007'
+#define MARK_AMP_STR "\007"
+
 /*
  * we need these regexps to find URLs in plain text e-mails
  */
@@ -81,18 +90,19 @@ struct _url_match_t {
        const gchar* prefix;
 };
 
+/* note: match MARK_AMP_STR as well, because after txt->html, a '&' will look like $(MARK_AMP_STR)"amp;" */
 #define MAIL_VIEWER_URL_MATCH_PATTERNS  {                              \
-       { "(file|rtsp|http|ftp|https)://[-A-Za-z0-9_$.+!*(),;:@%&=?/~#]+[-A-Za-z0-9_$%&=?/~#]",\
+       { "^(file|rtsp|http|ftp|https)://[-a-z0-9_$.+!*(),;:@%=?/~#" MARK_AMP_STR "]+[-a-z0-9_$%" MARK_AMP_STR "=?/~#]",\
          NULL, NULL },\
-       { "www\\.[-a-z0-9.]+[-a-z0-9](:[0-9]*)?(/[-A-Za-z0-9_$.+!*(),;:@%&=?/~#]*[^]}\\),?!;:\"]?)?",\
+       { "^www\\.[-a-z0-9_$.+!*(),;:@%=?/~#" MARK_AMP_STR "]+[-a-z0-9_$%" MARK_AMP_STR "=?/~#]",\
                        NULL, "http://" },                              \
-       { "ftp\\.[-a-z0-9.]+[-a-z0-9](:[0-9]*)?(/[-A-Za-z0-9_$.+!*(),;:@%&=?/~#]*[^]}\\),?!;:\"]?)?",\
+       { "^ftp\\.[-a-z0-9_$.+!*(),;:@%=?/~#" MARK_AMP_STR "]+[-a-z0-9_$%" MARK_AMP_STR "=?/~#]",\
          NULL, "ftp://" },\
-       { "(voipto|callto|chatto|jabberto|xmpp):[-_a-z@0-9.\\+]+", \
+       { "^(voipto|callto|chatto|jabberto|xmpp):[-_a-z@0-9.+]+", \
           NULL, NULL},                                             \
-       { "mailto:[-_a-z0-9.\\+]+@[-_a-z0-9.]+",                    \
+       { "^mailto:[-_a-z0-9.\\+]+@[-_a-z0-9.]+",                   \
          NULL, NULL},\
-       { "[-_a-z0-9.\\+]+@[-_a-z0-9.]+",\
+       { "^[-_a-z0-9.\\+]+@[-_a-z0-9.]+",\
          NULL, "mailto:"}\
        }
 
@@ -100,7 +110,7 @@ const gchar account_title_forbidden_chars[] = {
        '\\', '/', ':', '*', '?', '\'', '<', '>', '|', '^'
 };
 const gchar folder_name_forbidden_chars[] = {
-       '<', '>', ':', '\'', '/', '\\', '|', '?', '*', '^', '%', '$'
+       '<', '>', ':', '\'', '/', '\\', '|', '?', '*', '^', '%', '$', '#', '&'
 };
 const gchar user_name_forbidden_chars[] = {
        '<', '>'
@@ -278,12 +288,12 @@ modest_text_utils_derived_subject (const gchar *subject, const gchar *prefix)
 gchar*
 modest_text_utils_remove_address (const gchar *address_list, const gchar *address)
 {
-       gchar *dup, *token, *ptr, *result;
+       gchar *dup, *token, *ptr = NULL, *result;
        GString *filtered_emails;
        gchar *email_address;
 
        g_return_val_if_fail (address_list, NULL);
-
+       
        if (!address)
                return g_strdup (address_list);
 
@@ -320,10 +330,48 @@ modest_text_utils_remove_address (const gchar *address_list, const gchar *addres
        return result;
 }
 
+
+gchar*
+modest_text_utils_remove_duplicate_addresses (const gchar *address_list)
+{
+       GSList *addresses, *cursor;
+       GHashTable *table;
+       gchar *new_list;
+       
+       g_return_val_if_fail (address_list, NULL);
+
+       table = g_hash_table_new (g_str_hash, g_str_equal);
+       addresses = modest_text_utils_split_addresses_list (address_list);
+
+       new_list = g_strdup("");
+       cursor = addresses;
+       while (cursor) {
+               const gchar* address = (const gchar*)cursor->data;
+
+               /* ignore the address if already seen */
+               if (g_hash_table_lookup (table, address) == 0) {
+               
+                       gchar *tmp = g_strjoin (",", new_list, address, NULL);
+                       g_free (new_list);
+                       new_list = tmp;
+                       
+                       g_hash_table_insert (table, (gchar*)address, GINT_TO_POINTER(1));
+               }
+               cursor = g_slist_next (cursor);
+       }
+
+       g_hash_table_destroy (table);
+       g_slist_foreach (addresses, (GFunc)g_free, NULL);
+       g_slist_free (addresses);
+
+       return new_list;
+}
+
+
 static void
-modest_text_utils_convert_buffer_to_html (GString *html, const gchar *data, gssize n)
+modest_text_utils_convert_buffer_to_html_start (GString *html, const gchar *data, gssize n)
 {
-       guint            i;
+       guint           i;
        gboolean        space_seen = FALSE;
        guint           break_dist = 0; /* distance since last break point */
 
@@ -349,16 +397,21 @@ modest_text_utils_convert_buffer_to_html (GString *html, const gchar *data, gssi
                }
                
                switch (kar) {
-               case 0:  break; /* ignore embedded \0s */       
-               case '<'  : g_string_append (html, "&lt;");   break;
-               case '>'  : g_string_append (html, "&gt;");   break;
-               case '&'  : g_string_append (html, "&amp;");  break;
-               case '"'  : g_string_append (html, "&quot;");  break;
+               case 0:
+               case MARK_AMP: /* this is a temp place holder for '&'; we can only
+                               * set the real '&' after hyperlink translation, otherwise
+                               * we might screw that up */
+                       break; /* ignore embedded \0s and MARK_AMP */   
+               case '<'  : g_string_append (html, MARK_AMP_STR "lt;");   break;
+               case '>'  : g_string_append (html, MARK_AMP_STR "gt;");   break;
+               case '&'  : g_string_append (html, MARK_AMP_STR "amp;");  break;
+               case '"'  : g_string_append (html, MARK_AMP_STR "quot;");  break;
 
                /* don't convert &apos; --> wpeditor will try to re-convert it... */    
                //case '\'' : g_string_append (html, "&apos;"); break;
-               case '\n' : g_string_append (html, "<br>\n");              break_dist= 0; break;
-               case '\t' : g_string_append (html, "&nbsp;&nbsp;&nbsp; "); break_dist=0; break; /* note the space at the end*/
+               case '\n' : g_string_append (html, "<br>\n");break_dist= 0; break;
+               case '\t' : g_string_append (html, MARK_AMP_STR "nbsp;" MARK_AMP_STR "nbsp;" MARK_AMP_STR "nbsp; ");
+                       break_dist=0; break; /* note the space at the end*/
                case ' ':
                        break_dist = 0;
                        if (space_seen) { /* second space in a row */
@@ -373,11 +426,25 @@ modest_text_utils_convert_buffer_to_html (GString *html, const gchar *data, gssi
        }
 }
 
+
+static void
+modest_text_utils_convert_buffer_to_html_finish (GString *html)
+{
+       int i;
+       /* replace all our MARK_AMPs with real ones */
+       for (i = 0; i != html->len; ++i)
+               if ((html->str)[i] == MARK_AMP)
+                       (html->str)[i] = '&';
+}
+
+
 gchar*
 modest_text_utils_convert_to_html (const gchar *data)
 {
        GString         *html;      
        gsize           len;
+
+       g_return_val_if_fail (data, NULL);
        
        if (!data)
                return NULL;
@@ -391,13 +458,15 @@ modest_text_utils_convert_to_html (const gchar *data)
                                "</head>"
                                "<body>");
 
-       modest_text_utils_convert_buffer_to_html (html, data, -1);
+       modest_text_utils_convert_buffer_to_html_start (html, data, -1);
        
        g_string_append (html, "</body></html>");
 
        if (len <= HYPERLINKIFY_MAX_LENGTH)
                hyperlinkify_plain_text (html);
 
+       modest_text_utils_convert_buffer_to_html_finish (html);
+       
        return g_string_free (html, FALSE);
 }
 
@@ -405,7 +474,9 @@ gchar *
 modest_text_utils_convert_to_html_body (const gchar *data, gssize n, gboolean hyperlinkify)
 {
        GString         *html;      
-       
+
+       g_return_val_if_fail (data, NULL);
+
        if (!data)
                return NULL;
 
@@ -413,11 +484,13 @@ modest_text_utils_convert_to_html_body (const gchar *data, gssize n, gboolean hy
                n = strlen (data);
        html = g_string_sized_new (1.5 * n);    /* just a  guess... */
 
-       modest_text_utils_convert_buffer_to_html (html, data, n);
+       modest_text_utils_convert_buffer_to_html_start (html, data, n);
 
        if (hyperlinkify && (n < HYPERLINKIFY_MAX_LENGTH))
                hyperlinkify_plain_text (html);
 
+       modest_text_utils_convert_buffer_to_html_finish (html);
+       
        return g_string_free (html, FALSE);
 }
 
@@ -479,6 +552,7 @@ modest_text_utils_get_addresses_indexes (const gchar *addresses, GSList **start_
        return;
 }
 
+#if 0
 GSList *
 modest_text_utils_split_addresses_list (const gchar *addresses)
 {
@@ -521,6 +595,43 @@ modest_text_utils_split_addresses_list (const gchar *addresses)
        return result;
 
 }
+#endif
+
+
+
+
+GSList *
+modest_text_utils_split_addresses_list (const gchar *addresses)
+{
+       GSList *head;
+       const gchar *my_addrs = addresses;
+       const gchar *end;
+       gchar *addr;
+       
+       /* skip any space, ',', ';' at the start */
+       while (my_addrs && (my_addrs[0] == ' ' || my_addrs[0] == ',' || my_addrs[0] == ';'))
+              ++my_addrs;
+
+       /* are we at the end of addresses list? */
+       if (!my_addrs[0])
+               return NULL;
+       
+       /* nope, we are at the start of some address
+        * now, let's find the end of the address */
+       end = my_addrs + 1;
+       while (end[0] && end[0] != ',' && end[0] != ';')
+               ++end;
+
+       /* we got the address; copy it and remove trailing whitespace */
+       addr = g_strndup (my_addrs, end - my_addrs);
+       g_strchomp (addr);
+
+       head = g_slist_append (NULL, addr);
+       head->next = modest_text_utils_split_addresses_list (end); /* recurse */
+
+       return head;
+}
+
 
 void
 modest_text_utils_address_range_at_position (const gchar *recipients_list,
@@ -862,8 +973,11 @@ compile_patterns ()
                patterns[i].preg = g_slice_new0 (regex_t);
                
                /* this should not happen */
-               g_return_val_if_fail (regcomp (patterns[i].preg, patterns[i].regex,
-                                              REG_ICASE|REG_EXTENDED|REG_NEWLINE) == 0, FALSE);
+               if (regcomp (patterns[i].preg, patterns[i].regex,
+                            REG_ICASE|REG_EXTENDED|REG_NEWLINE) != 0) {
+                       g_warning ("%s: error in regexp:\n%s\n", __FUNCTION__, patterns[i].regex);
+                       return FALSE;
+               }
        }
        return TRUE;
 }
@@ -942,8 +1056,7 @@ get_url_matches (GString *txt)
                                match->len    = rm.rm_eo - rm.rm_so;
                                match->prefix = patterns[i].prefix;
                                match_list = g_slist_prepend (match_list, match);
-                       }
-                               
+                       }               
                        offset += rm.rm_eo;
                }
        }
@@ -961,6 +1074,29 @@ get_url_matches (GString *txt)
 
 
 
+/* replace all occurences of needle in haystack with repl*/
+static gchar*
+replace_string (const gchar *haystack, const gchar *needle, gchar repl)
+{
+       gchar *str, *cursor;
+
+       if (!haystack || !needle || strlen(needle) == 0)
+               return haystack ? g_strdup(haystack) : NULL;
+       
+       str = g_strdup (haystack);
+
+       for (cursor = str; cursor && *cursor; ++cursor) {
+               if (g_str_has_prefix (cursor, needle)) {
+                       cursor[0] = repl;
+                       memmove (cursor + 1,
+                                cursor + strlen (needle),
+                                strlen (cursor + strlen (needle)) + 1);
+               }
+       }
+       
+       return str;
+}
+
 static void
 hyperlinkify_plain_text (GString *txt)
 {
@@ -974,10 +1110,17 @@ hyperlinkify_plain_text (GString *txt)
                gchar *url  = g_strndup (txt->str + match->offset, match->len);
                gchar *repl = NULL; /* replacement  */
 
+               /* the string still contains $(MARK_AMP_STR)"amp;" for each
+                * '&' in the original, because of the text->html conversion.
+                * in the href-URL (and only there), we must convert that back to
+                * '&'
+                */
+               gchar *href_url = replace_string (url, MARK_AMP_STR "amp;", '&');
+               
                /* the prefix is NULL: use the one that is already there */
                repl = g_strdup_printf ("<a href=\"%s%s\">%s</a>",
                                        match->prefix ? match->prefix : EMPTY_STRING, 
-                                       url, url);
+                                       href_url, url);
 
                /* replace the old thing with our hyperlink
                 * replacement thing */
@@ -986,6 +1129,7 @@ hyperlinkify_plain_text (GString *txt)
                
                g_free (url);
                g_free (repl);
+               g_free (href_url);
 
                g_slice_free (url_match_t, match);      
        }
@@ -999,6 +1143,8 @@ void
 modest_text_utils_get_display_address (gchar *address)
 {
        int i;
+
+       g_return_if_fail (address);
        
        if (!address)
                return;
@@ -1032,6 +1178,8 @@ gchar *
 modest_text_utils_get_email_address (const gchar *full_address)
 {
        const gchar *left, *right;
+
+       g_return_val_if_fail (full_address, NULL);
        
        if (!full_address)
                return NULL;
@@ -1052,86 +1200,109 @@ modest_text_utils_get_email_address (const gchar *full_address)
 gint 
 modest_text_utils_get_subject_prefix_len (const gchar *sub)
 {
-       gint i;
-       static const gchar* prefix[] = {
-               "Re:", "RE:", "RV:", "re:"
-               "Fwd:", "FWD:", "FW:", "fwd:", "Fw:", "fw:", NULL
-       };
-               
-       if (!sub || (sub[0] != 'R' && sub[0] != 'F' && sub[0] != 'r' && sub[0] != 'f')) /* optimization */
-               return 0;
+       gint prefix_len = 0;    
 
-       i = 0;
+       g_return_val_if_fail (sub, 0);
+
+       if (!sub)
+               return 0;
        
-       while (prefix[i]) {
-               if (g_str_has_prefix(sub, prefix[i])) {
-                       int prefix_len = strlen(prefix[i]); 
-                       if (sub[prefix_len] == ' ')
-                               ++prefix_len; /* ignore space after prefix as well */
-                       return prefix_len; 
-               }
-               ++i;
+       /* optimization: "Re", "RE", "re","Fwd", "FWD", "fwd","FW","Fw", "fw" */
+       if (sub[0] != 'R' && sub[0] != 'F' && sub[0] != 'r' && sub[0] != 'f')
+               return 0;
+       else if (sub[0] && sub[1] != 'e' && sub[1] != 'E' && sub[1] != 'w' && sub[1] != 'W')
+               return 0;
+
+       prefix_len = 2;
+       if (sub[2] == 'd')
+               ++prefix_len;
+
+       /* skip over a [...] block */
+       if (sub[prefix_len] == '[') {
+               int c = prefix_len + 1;
+               while (sub[c] && sub[c] != ']')
+                       ++c;
+               if (sub[c])
+                       return 0; /* no end to the ']' found */
+               else
+                       prefix_len = c + 1;
        }
-       return 0;
+
+       /* did we find the ':' ? */
+       if (sub[prefix_len] == ':') {
+               ++prefix_len;
+               if (sub[prefix_len] == ' ')
+                       ++prefix_len;
+               prefix_len += modest_text_utils_get_subject_prefix_len (sub + prefix_len);
+/*             g_warning ("['%s','%s']", sub, (char*) sub + prefix_len); */
+               return prefix_len;
+       } else
+               return 0;
 }
 
 
 gint
 modest_text_utils_utf8_strcmp (const gchar* s1, const gchar *s2, gboolean insensitive)
 {
-       gint result = 0;
-       gchar *n1, *n2;
 
-       /* work even when s1 and/or s2 == NULL */
+/* work even when s1 and/or s2 == NULL */
        if (G_UNLIKELY(s1 == s2))
                return 0;
-
-       /* if it's not case sensitive */
-       if (!insensitive)
-               return strcmp (s1 ? s1 : "", s2 ? s2 : "");
+       if (G_UNLIKELY(!s1))
+               return -1;
+       if (G_UNLIKELY(!s2))
+               return 1;
        
-       n1 = g_utf8_collate_key (s1 ? s1 : "", -1);
-       n2 = g_utf8_collate_key (s2 ? s2 : "", -1);
-       
-       result = strcmp (n1, n2);
+       /* if it's not case sensitive */
+       if (!insensitive) {
 
-       g_free (n1);
-       g_free (n2);
+               /* optimization: short cut if first char is ascii */ 
+               if (((s1[0] & 0xf0)== 0) && ((s2[0] & 0xf0) == 0)) 
+                       return s1[0] - s2[0];
+               
+               return g_utf8_collate (s1, s2);
+
+       } else {
+               gint result;
+               gchar *n1, *n2;
+
+               /* optimization: short cut iif first char is ascii */ 
+               if (((s1[0] & 0xf0) == 0) && ((s2[0] & 0xf0) == 0)) 
+                       return tolower(s1[0]) - tolower(s2[0]);
+               
+               n1 = g_utf8_strdown (s1, -1);
+               n2 = g_utf8_strdown (s2, -1);
+               
+               result = g_utf8_collate (n1, n2);
+               
+               g_free (n1);
+               g_free (n2);
        
-       return result;
+               return result;
+       }
 }
 
 
 const gchar*
 modest_text_utils_get_display_date (time_t date)
 {
-       time_t now;
 #define DATE_BUF_SIZE 64 
-       static const guint ONE_DAY = 24 * 60 * 60; /* seconds in one day */
        static gchar date_buf[DATE_BUF_SIZE];
+       
+       /* calculate the # of days since epoch for 
+        * for today and for the date provided 
+        * based on idea from pvanhoof */
+       int day      = time(NULL) / (24 * 60 * 60);
+       int date_day = date       / (24 * 60 * 60);
 
-       gchar today_buf [DATE_BUF_SIZE];  
-
-       modest_text_utils_strftime (date_buf, DATE_BUF_SIZE, "%x", date); 
-
-       now = time (NULL);
+       /* if it's today, show the time, if it's not today, show the date instead */
 
-       /* we check if the date is within the last 24h, if not, we don't
-        * have to do the extra, expensive strftime, which was very visible
-        * in the profiles.
-        */
-       if (abs(now - date) < ONE_DAY) {
-               
-               /* it's within the last 24 hours, but double check */
-               /* use the localized dates */
-               modest_text_utils_strftime (today_buf,  DATE_BUF_SIZE, "%x", now); 
+       if (day == date_day) /* is the date today? */
+               modest_text_utils_strftime (date_buf, DATE_BUF_SIZE, "%X", date);
+       else 
+               modest_text_utils_strftime (date_buf, DATE_BUF_SIZE, "%x", date); 
 
-               /* if it's today, use the time instead */
-               if (strcmp (date_buf, today_buf) == 0)
-                       modest_text_utils_strftime (date_buf, DATE_BUF_SIZE, "%X", date);
-       }
-       
-       return date_buf;
+       return date_buf; /* this is a static buffer, don't free! */
 }
 
 
@@ -1176,6 +1347,7 @@ modest_text_utils_validate_folder_name (const gchar *folder_name)
                                return FALSE;
                }
        }
+
        return TRUE; /* it's valid! */
 }
 
@@ -1186,13 +1358,15 @@ modest_text_utils_validate_domain_name (const gchar *domain)
 {
        gboolean valid = FALSE;
        regex_t rx;
-       const gchar* domain_regex = "^[a-z0-9]([.]?[a-z0-9-])*[a-z0-9]$";
+       const gchar* domain_regex = "^([a-z0-9-]*[a-z0-9]\\.)+[a-z0-9-]*[a-z0-9]$";
 
-       memset (&rx, 0, sizeof(regex_t)); /* coverity wants this... */
+       g_return_val_if_fail (domain, FALSE);
        
        if (!domain)
                return FALSE;
        
+       memset (&rx, 0, sizeof(regex_t)); /* coverity wants this... */
+               
        /* domain name: all alphanum or '-' or '.',
         * but beginning/ending in alphanum */  
        if (regcomp (&rx, domain_regex, REG_ICASE|REG_EXTENDED|REG_NOSUB)) {
@@ -1209,21 +1383,22 @@ modest_text_utils_validate_domain_name (const gchar *domain)
 
 
 gboolean
-modest_text_utils_validate_email_address (const gchar *email_address, const gchar **invalid_char_position)
+modest_text_utils_validate_email_address (const gchar *email_address,
+                                         const gchar **invalid_char_position)
 {
        int count = 0;
        const gchar *c = NULL, *domain = NULL;
        static gchar *rfc822_specials = "()<>@,;:\\\"[]&";
-
-       if (invalid_char_position != NULL)
+       
+       if (invalid_char_position)
                *invalid_char_position = NULL;
        
+       g_return_val_if_fail (email_address, FALSE);
+       
        /* check that the email adress contains exactly one @ */
        if (!strstr(email_address, "@") || 
-                       (strstr(email_address, "@") != g_strrstr(email_address, "@")))
-       {
+                       (strstr(email_address, "@") != g_strrstr(email_address, "@"))) 
                return FALSE;
-       }
        
        /* first we validate the name portion (name@domain) */
        for (c = email_address;  *c;  c++) {
@@ -1288,8 +1463,14 @@ modest_text_utils_validate_recipient (const gchar *recipient, const gchar **inva
        gchar *right_part;
        gboolean has_error = FALSE;
 
+       if (invalid_char_position)
+               *invalid_char_position = NULL;
+       
+       g_return_val_if_fail (recipient, FALSE);
+       
        if (modest_text_utils_validate_email_address (recipient, invalid_char_position))
                return TRUE;
+
        stripped = g_strdup (recipient);
        stripped = g_strstrip (stripped);
        current = stripped;
@@ -1395,7 +1576,8 @@ get_email_from_address (const gchar * address)
 gchar *      
 modest_text_utils_get_color_string (GdkColor *color)
 {
-
+       g_return_val_if_fail (color, NULL);
+       
        return g_strdup_printf ("#%x%x%x%x%x%x%x%x%x%x%x%x",
                                (color->red >> 12)   & 0xf, (color->red >> 8)   & 0xf,
                                (color->red >>  4)   & 0xf, (color->red)        & 0xf,
@@ -1412,8 +1594,8 @@ modest_text_utils_text_buffer_get_text (GtkTextBuffer *buffer)
        gchar *slice, *current;
        GString *result = g_string_new ("");
 
-       g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
-
+       g_return_val_if_fail (buffer && GTK_IS_TEXT_BUFFER (buffer), NULL);
+       
        gtk_text_buffer_get_start_iter (buffer, &start);
        gtk_text_buffer_get_end_iter (buffer, &end);