email-common-use/email-utilities.c

   1 /*\r
   2 *  email-service\r
   3 *\r
   4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
   5 *\r
   6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
   7 *\r
   8 * Licensed under the Apache License, Version 2.0 (the "License");\r
   9 * you may not use this file except in compliance with the License.\r
  10 * You may obtain a copy of the License at\r
  11 *\r
  12 * http://www.apache.org/licenses/LICENSE-2.0\r
  13 *\r
  14 * Unless required by applicable law or agreed to in writing, software\r
  15 * distributed under the License is distributed on an "AS IS" BASIS,\r
  16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17 * See the License for the specific language governing permissions and\r
  18 * limitations under the License.\r
  19 *\r
  20 */\r
  21 \r
  22 /*\r
  23  * email-utilities.c\r
  24  *\r
  25  *  Created on: 2012. 3. 6.\r
  26  *      Author: kyuho.jo@samsung.com\r
  27  */\r
  28 #include <stdio.h>\r
  29 #include <stdlib.h>\r
  30 #include <string.h>\r
  31 #include <ctype.h>\r
  32 #include <errno.h>\r
  33 #include <sys/time.h>\r
  34 #include <sys/vfs.h>\r
  35 #include <unistd.h>\r
  36 #include <malloc.h>\r
  37 #include <pthread.h>\r
  38 #include <regex.h>\r
  39 \r
  40 #include "c-client.h"\r
  41 \r
  42 #include "email-types.h"\r
  43 #include "email-internal-types.h"\r
  44 #include "email-utilities.h"\r
  45 \r
  46 INTERNAL_FUNC void* em_malloc(unsigned len)\r
  47 {\r
  48         /* EM_DEBUG_LOG("Memory allocation size[%d] bytes", len); */\r
  49         void *p = NULL;\r
  50 \r
  51         if (len <= 0) {\r
  52                 EM_DEBUG_EXCEPTION("len should be positive.[%d]", len);\r
  53                 return NULL;\r
  54         }\r
  55 \r
  56         p = malloc(len);\r
  57 \r
  58         if (p)\r
  59                 memset(p, 0x00, len);\r
  60         else\r
  61                 EM_DEBUG_EXCEPTION("malloc failed");\r
  62         return p;\r
  63 }\r
  64 \r
  65 /*  remove left space, tab, CR, L */\r
  66 INTERNAL_FUNC char *em_trim_left(char *str)\r
  67 {\r
  68         char *p, *temp_buffer = NULL;\r
  69 \r
  70         /* EM_DEBUG_FUNC_BEGIN() */\r
  71         if (!str) return NULL;\r
  72 \r
  73         p = str;\r
  74         while (*p && (*p == ' ' || *p == '\t' || *p == LF || *p == CR)) p++;\r
  75 \r
  76         if (!*p) return NULL;\r
  77 \r
  78         temp_buffer = EM_SAFE_STRDUP(p);\r
  79 \r
  80         strncpy(str, temp_buffer, strlen(str));\r
  81         str[strlen(temp_buffer)] = NULL_CHAR;\r
  82 \r
  83         EM_SAFE_FREE(temp_buffer);\r
  84 \r
  85         return str;\r
  86 }\r
  87 \r
  88 /*  remove right space, tab, CR, L */\r
  89 INTERNAL_FUNC char *em_trim_right(char *str)\r
  90 {\r
  91         char *p;\r
  92 \r
  93         /* EM_DEBUG_FUNC_BEGIN() */\r
  94         if (!str) return NULL;\r
  95 \r
  96         p = str+strlen(str)-1;\r
  97         while (((int)p >= (int)str) && (*p == ' ' || *p == '\t' || *p == LF || *p == CR))\r
  98                 *p --= '\0';\r
  99 \r
 100         if ((int) p < (int)str)\r
 101                 return NULL;\r
 102 \r
 103         return str;\r
 104 }\r
 105 \r
 106 INTERNAL_FUNC char* em_upper_string(char *str)\r
 107 {\r
 108         char *p = str;\r
 109         while (*p)  {\r
 110                 *p = toupper(*p);\r
 111                 p++;\r
 112         }\r
 113         return str;\r
 114 }\r
 115 \r
 116 INTERNAL_FUNC char*  em_lower_string(char *str)\r
 117 {\r
 118         char *p = str;\r
 119         while (*p)  {\r
 120                 *p = tolower(*p);\r
 121                 p++;\r
 122         }\r
 123         return str;\r
 124 }\r
 125 \r
 126 INTERNAL_FUNC int em_upper_path(char *path)\r
 127 {\r
 128         int i = 0, is_utf7 = 0, len = path ? (int)strlen(path) : -1;\r
 129         for (; i < len; i++) {\r
 130                 if (path[i] == '&' || path[i] == 5) {\r
 131                         is_utf7 = 1;\r
 132                 }\r
 133                 else {\r
 134                         if (is_utf7) {\r
 135                                 if (path[i] == '-') is_utf7 = 0;\r
 136                         }\r
 137                         else {\r
 138                                 path[i] = toupper(path[i]);\r
 139                         }\r
 140                 }\r
 141         }\r
 142 \r
 143         return 1;\r
 144 }\r
 145 \r
 146 INTERNAL_FUNC void em_skip_whitespace(char *addr_str, char **pAddr)\r
 147 {\r
 148         EM_DEBUG_FUNC_BEGIN("addr_str[%p]", addr_str);\r
 149 \r
 150         if (!addr_str)\r
 151                 return ;\r
 152         char *str = addr_str;\r
 153         char ptr[strlen(str)+1]  ;\r
 154         int i, j = 0;\r
 155 \r
 156         str = addr_str ;\r
 157         for (i = 0; str[i] != NULL_CHAR ; i++) {\r
 158                 if (str[i] != SPACE && str[i] != TAB && str[i] != CR && str[i] != LF)\r
 159                         ptr[j++] = str[i];\r
 160         }\r
 161         ptr[j] = NULL_CHAR;\r
 162 \r
 163         *pAddr = EM_SAFE_STRDUP(ptr);\r
 164         EM_DEBUG_FUNC_END("ptr[%s]", ptr);\r
 165 }\r
 166 \r
 167 INTERNAL_FUNC char* em_skip_whitespace_without_strdup(char *source_string)\r
 168 {\r
 169         EM_DEBUG_FUNC_BEGIN("source_string[%p]", source_string);\r
 170 \r
 171         if (!source_string)\r
 172                 return NULL;\r
 173         int i;\r
 174 \r
 175         for (i = 0; source_string[i] != NULL_CHAR ; i++) {\r
 176                 if (source_string[i] != SPACE) /*  || source_string[i] != TAB || source_string[i] != CR || source_string[i] || LF) */\r
 177                         break;\r
 178         }\r
 179 \r
 180         EM_DEBUG_FUNC_END("i[%d]", i);\r
 181         return source_string + i;\r
 182 }\r
 183 \r
 184 INTERNAL_FUNC char* em_replace_string(char *source_string, char *old_string, char *new_string)\r
 185 {\r
 186         EM_DEBUG_FUNC_BEGIN();\r
 187         char *result_buffer = NULL;\r
 188         char *p = NULL;\r
 189         int   buffer_length = 0;\r
 190 \r
 191         EM_IF_NULL_RETURN_VALUE(source_string, NULL);\r
 192         EM_IF_NULL_RETURN_VALUE(old_string, NULL);\r
 193         EM_IF_NULL_RETURN_VALUE(new_string, NULL);\r
 194 \r
 195         p = strstr(source_string, old_string);\r
 196 \r
 197         if (p == NULL) {\r
 198                 EM_DEBUG_EXCEPTION("old_string not found in source_string");\r
 199                 EM_DEBUG_FUNC_END("return NULL");\r
 200                 return NULL;\r
 201         }\r
 202 \r
 203         buffer_length   = strlen(source_string) + 1024;\r
 204         result_buffer  = (char *)em_malloc(buffer_length);\r
 205 \r
 206         if (!result_buffer) {\r
 207                 EM_DEBUG_EXCEPTION("em_malloc failed");\r
 208                 return NULL;\r
 209         }\r
 210 \r
 211         strncpy(result_buffer, source_string, p - source_string);\r
 212         snprintf(result_buffer + strlen(result_buffer), buffer_length - strlen(result_buffer), "%s%s", new_string, p + strlen(old_string));\r
 213 \r
 214         EM_DEBUG_FUNC_END("result_buffer[%s]", result_buffer);\r
 215         return result_buffer;\r
 216 }\r
 217 \r
 218 /* Memory clean up */\r
 219 #include <sys/mman.h>\r
 220 \r
 221 /* #define GETSP()                              ({ unsigned int sp; asm volatile ("mov %0, sp " : "=r"(sp)); sp;}) */\r
 222 #define BUF_SIZE                                256\r
 223 #define PAGE_SIZE                           (1 << 12)\r
 224 #define _ALIGN_UP(addr, size)   (((addr)+((size)-1))&(~((size)-1)))\r
 225 #define _ALIGN_DOWN(addr, size) ((addr)&(~((size)-1)))\r
 226 #define PAGE_ALIGN(addr)        _ALIGN_DOWN(addr, PAGE_SIZE)\r
 227 \r
 228 int stack_trim(void)\r
 229 {\r
 230         /*\r
 231         char buf[BUF_SIZE];\r
 232         FILE *file;\r
 233         unsigned int stacktop;\r
 234         int found = 0;\r
 235         unsigned int sp;\r
 236 \r
 237         asm volatile ("mov %0, sp " : "=r"(sp));\r
 238 \r
 239         sprintf(buf, "/proc/%d/maps", getpid());\r
 240         file = fopen(buf, "r");\r
 241         while (fgets(buf, BUF_SIZE, file) != NULL) {\r
 242                 if (strstr(buf, "[stack]")) {\r
 243                         found = 1;\r
 244                         break;\r
 245                 }\r
 246         }\r
 247 \r
 248         fclose(file);\r
 249 \r
 250         if (found) {\r
 251                 sscanf(buf, "%x-", &stacktop);\r
 252                 if (madvise((void *)PAGE_ALIGN(stacktop), PAGE_ALIGN(sp)-stacktop, MADV_DONTNEED) < 0)\r
 253                         perror("stack madvise fail");\r
 254         }\r
 255         */\r
 256         return 1;\r
 257 }\r
 258 \r
 259 INTERNAL_FUNC void em_flush_memory()\r
 260 {\r
 261         EM_DEBUG_FUNC_BEGIN();\r
 262         /*  flush memory in heap */\r
 263         malloc_trim(0);\r
 264 \r
 265         /*  flush memory in stack */\r
 266         stack_trim();\r
 267 \r
 268         /*  flush memory for sqlite */\r
 269         emstorage_flush_db_cache();\r
 270         EM_DEBUG_FUNC_END();\r
 271 }\r
 272 \r
 273 #define DATE_TIME_STRING_LEGNTH 14\r
 274 \r
 275 INTERNAL_FUNC char *em_get_extension_from_file_path(char *source_file_path, int *err_code)\r
 276 {\r
 277         EM_DEBUG_FUNC_BEGIN("source_file_path[%s]", source_file_path);\r
 278         int err = EMF_ERROR_NONE, pos_on_string = 0;\r
 279         char *extension = NULL;\r
 280 \r
 281         if (!source_file_path) {\r
 282                 EM_DEBUG_EXCEPTION("Invalid Parameter");\r
 283                 err  = EMF_ERROR_INVALID_PARAM;\r
 284                 goto FINISH_OFF;\r
 285         }\r
 286 \r
 287         pos_on_string = strlen(source_file_path) - 1;\r
 288 \r
 289         while(pos_on_string > 0 && source_file_path[pos_on_string--] != '.') ;\r
 290 \r
 291         if(pos_on_string > 0)\r
 292                 extension = source_file_path + pos_on_string + 2;\r
 293 \r
 294         EM_DEBUG_LOG("*extension [%s] pos_on_string [%d]", extension, pos_on_string);\r
 295 \r
 296 FINISH_OFF:\r
 297         if (err_code)\r
 298                 *err_code = err;\r
 299         EM_DEBUG_FUNC_END();\r
 300         return extension;\r
 301 }\r
 302 \r
 303 INTERNAL_FUNC int em_get_encoding_type_from_file_path(const char *input_file_path, char **output_encoding_type)\r
 304 {\r
 305         EM_DEBUG_FUNC_BEGIN("input_file_path[%d], output_encoding_type[%p]", input_file_path, output_encoding_type);\r
 306         int   err = EMF_ERROR_NONE;\r
 307         int   pos_of_filename = 0;\r
 308         int   pos_of_dot = 0;\r
 309         int   enf_of_string = 0;\r
 310         int   result_string_length = 0;\r
 311         char *filename = NULL;\r
 312         char *result_encoding_type = NULL;\r
 313 \r
 314         if (!input_file_path || !output_encoding_type) {\r
 315                 EM_DEBUG_EXCEPTION("Invalid Parameter");\r
 316                 err  = EMF_ERROR_INVALID_PARAM;\r
 317                 goto FINISH_OFF;\r
 318         }\r
 319 \r
 320         enf_of_string = pos_of_filename = strlen(input_file_path) - 1;\r
 321 \r
 322         while(pos_of_filename >= 0 && input_file_path[pos_of_filename--] != '/') {\r
 323                 if(input_file_path[pos_of_filename] == '.')\r
 324                         pos_of_dot = pos_of_filename;\r
 325         }\r
 326 \r
 327         if(pos_of_filename != 0)\r
 328                 pos_of_filename += 2;\r
 329 \r
 330         filename = (char*)input_file_path + pos_of_filename;\r
 331 \r
 332         if(pos_of_dot != 0 && pos_of_dot > pos_of_filename)\r
 333                 result_string_length = pos_of_dot - pos_of_filename;\r
 334         else\r
 335                 result_string_length = enf_of_string - pos_of_filename;\r
 336 \r
 337         EM_DEBUG_LOG("pos_of_dot [%d], pos_of_filename [%d], enf_of_string[%d],result_string_length [%d]", pos_of_dot, pos_of_filename, enf_of_string, result_string_length);\r
 338 \r
 339         if( !(result_encoding_type =    em_malloc(sizeof(char) * (result_string_length + 1))) ) {\r
 340                 EM_DEBUG_EXCEPTION("EMF_ERROR_OUT_OF_MEMORY");\r
 341                 err  = EMF_ERROR_OUT_OF_MEMORY;\r
 342                 goto FINISH_OFF;\r
 343         }\r
 344 \r
 345         memcpy(result_encoding_type, input_file_path + pos_of_filename, result_string_length);\r
 346 \r
 347         EM_DEBUG_LOG("*result_encoding_type [%s]", result_encoding_type);\r
 348 \r
 349         *output_encoding_type = result_encoding_type;\r
 350 \r
 351 FINISH_OFF:\r
 352         EM_DEBUG_FUNC_END("err [%d]", err);\r
 353         return err;\r
 354 }\r
 355 \r
 356 INTERNAL_FUNC int em_get_content_type_from_extension_string(const char *extension_string, int *err_code)\r
 357 {\r
 358         EM_DEBUG_FUNC_BEGIN("extension_string[%s]", extension_string);\r
 359         int i = 0, err = EMF_ERROR_NONE, result_content_type = TYPEAPPLICATION;\r
 360         char *image_extension[] = { "jpeg", "jpg", "png", "gif", "bmp", "pic", "agif", "tif", "wbmp" , NULL};\r
 361 \r
 362         if (!extension_string) {\r
 363                 EM_DEBUG_EXCEPTION("Invalid Parameter");\r
 364                 err  = EMF_ERROR_INVALID_PARAM;\r
 365                 goto FINISH_OFF;\r
 366         }\r
 367 \r
 368         while(image_extension[i]) {\r
 369                 EM_DEBUG_LOG("image_extension[%d] [%s]", i, image_extension[i]);\r
 370                 if(strcasecmp(image_extension[i], extension_string) == 0) {\r
 371                         result_content_type = TYPEIMAGE;\r
 372                         break;\r
 373                 }\r
 374                 i++;\r
 375         }\r
 376 \r
 377 FINISH_OFF:\r
 378         if (err_code)\r
 379                 *err_code = err;\r
 380         EM_DEBUG_FUNC_END();\r
 381         return result_content_type;\r
 382 }\r
 383 \r
 384 #define EMAIL_ACCOUNT_RGEX                     "([a-z0-9!#$%&'*+/=?^_`{|}~-]+.)*[a-z0-9!#$%&'*+/=?^_`{|}~-]+"\r
 385 #define EMAIL_DOMAIN_RGEX                      "([a-z0-9!#$%&'*+/=?^_`{|}~-]+.)+[a-z0-9!#$%&'*+/=?^_`{|}~-]+"\r
 386 \r
 387 #define EMAIL_ADDR_RGEX                        "[[:space:]]*<"EMAIL_ACCOUNT_RGEX"@"EMAIL_DOMAIN_RGEX">[[:space:]]*"\r
 388 #define EMAIL_ALIAS_RGEX                       "([[:space:]]*\"[^\"]*\")?"EMAIL_ADDR_RGEX\r
 389 #define EMAIL_ALIAS_LIST_RGEX                  "^("EMAIL_ALIAS_RGEX"[;,])*"EMAIL_ALIAS_RGEX"[;,]?[[:space:]]*$"\r
 390 \r
 391 #define EMAIL_ADDR_WITHOUT_BRACKET_RGEX        "[[:space:]]*"EMAIL_ACCOUNT_RGEX"@"EMAIL_DOMAIN_RGEX"[[:space:]]*"\r
 392 #define EMAIL_ALIAS_WITHOUT_BRACKET_RGEX       "([[:space:]]*\"[^\"]*\")?"EMAIL_ADDR_WITHOUT_BRACKET_RGEX\r
 393 #define EMAIL_ALIAS_LIST_WITHOUT_BRACKET_RGEX  "("EMAIL_ALIAS_WITHOUT_BRACKET_RGEX"[;,])*"EMAIL_ADDR_WITHOUT_BRACKET_RGEX"[;,]?[[:space:]]*$"\r
 394 \r
 395 INTERNAL_FUNC int em_verify_email_address(char *address, int without_bracket, int *err_code)\r
 396 {\r
 397         EM_DEBUG_FUNC_BEGIN("address[%s] without_bracket[%d]", address, without_bracket);\r
 398 \r
 399         /*  this following code verfies the email alias string using reg. exp. */\r
 400         regex_t alias_list_regex = {0};\r
 401         int ret = false, error = EMF_ERROR_NONE;\r
 402         char *reg_rule = NULL;\r
 403 \r
 404         if(!address || strlen(address) == 0) {\r
 405                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");\r
 406                 if (err_code)\r
 407                         *err_code = EMF_ERROR_INVALID_PARAM;\r
 408                 return false;\r
 409         }\r
 410 \r
 411         if(without_bracket)\r
 412                 reg_rule = EMAIL_ALIAS_LIST_WITHOUT_BRACKET_RGEX;\r
 413         else\r
 414                 reg_rule = EMAIL_ALIAS_LIST_RGEX;\r
 415 \r
 416         if (regcomp(&alias_list_regex, reg_rule, REG_ICASE | REG_EXTENDED)) {\r
 417                 EM_DEBUG_EXCEPTION("email alias regex unrecognized");\r
 418                 if (err_code)\r
 419                         *err_code = EMF_ERROR_UNKNOWN;\r
 420                 return false;\r
 421         }\r
 422 \r
 423         int alias_len = strlen(address) + 1;\r
 424         regmatch_t pmatch[alias_len];\r
 425 \r
 426         bzero(pmatch, alias_len);\r
 427 \r
 428         if (regexec(&alias_list_regex, address, alias_len, pmatch, 0) == REG_NOMATCH)\r
 429                 EM_DEBUG_LOG("failed :[%s]", address);\r
 430         else {\r
 431                 EM_DEBUG_LOG("success :[%s]", address);\r
 432                 ret = true;\r
 433         }\r
 434 \r
 435         regfree(&alias_list_regex);\r
 436 \r
 437         if (err_code)\r
 438                 *err_code = error;\r
 439 \r
 440         EM_DEBUG_FUNC_END("ret [%d]", ret);\r
 441         return ret;\r
 442 }\r
 443 \r
 444 INTERNAL_FUNC int em_verify_email_address_of_mail_data(emf_mail_data_t *mail_data, int without_bracket, int *err_code)\r
 445 {\r
 446         EM_DEBUG_FUNC_BEGIN("mail_data[%p] without_bracket[%d]", mail_data, without_bracket);\r
 447         char *address_array[4] = { mail_data->full_address_from, mail_data->full_address_to, mail_data->full_address_cc, mail_data->full_address_bcc};\r
 448         int  ret = false, err = EMF_ERROR_NONE, i;\r
 449 \r
 450         /* check for email_address validation */\r
 451         for (i = 0; i < 4; i++) {\r
 452                 if (address_array[i] && address_array[i][0] != 0) {\r
 453                         if (!em_verify_email_address(address_array[i] , without_bracket, &err)) {\r
 454                                 err = EMF_ERROR_INVALID_ADDRESS;\r
 455                                 EM_DEBUG_EXCEPTION("Invalid Email Address [%d][%s]", i, address_array[i]);\r
 456                                 goto FINISH_OFF;\r
 457                         }\r
 458                 }\r
 459         }\r
 460         ret = true;\r
 461 FINISH_OFF:\r
 462         EM_DEBUG_FUNC_END("ret [%d]", ret);\r
 463         return ret;\r
 464 }\r
 465 \r
 466 INTERNAL_FUNC int em_verify_email_address_of_mail_tbl(emstorage_mail_tbl_t *input_mail_tbl, int input_without_bracket)\r
 467 {\r
 468         EM_DEBUG_FUNC_BEGIN("input_mail_tbl[%p] input_without_bracket[%d]", input_mail_tbl, input_without_bracket);\r
 469         char *address_array[4] = { input_mail_tbl->full_address_to, input_mail_tbl->full_address_cc, input_mail_tbl->full_address_bcc, input_mail_tbl->full_address_from};\r
 470         int  err = EMF_ERROR_NONE, i;\r
 471 \r
 472         /* check for email_address validation */\r
 473         for (i = 0; i < 4; i++) {\r
 474                 if (address_array[i] && address_array[i][0] != 0) {\r
 475                         if (!em_verify_email_address(address_array[i] , input_without_bracket, &err)) {\r
 476                                 err = EMF_ERROR_INVALID_ADDRESS;\r
 477                                 EM_DEBUG_EXCEPTION("Invalid Email Address [%d][%s]", i, address_array[i]);\r
 478                                 goto FINISH_OFF;\r
 479                         }\r
 480                 }\r
 481         }\r
 482 \r
 483 FINISH_OFF:\r
 484         EM_DEBUG_FUNC_END("err [%d]", err);\r
 485         return err;\r
 486 }\r
 487 \r
 488 INTERNAL_FUNC int em_find_tag_for_thread_view(char *subject, int *result)\r
 489 {\r
 490         EM_DEBUG_FUNC_BEGIN();\r
 491         int error_code = EMF_ERROR_NONE;\r
 492         char *copy_of_subject = NULL;\r
 493 \r
 494         EM_IF_NULL_RETURN_VALUE(subject, EMF_ERROR_INVALID_PARAM);\r
 495         EM_IF_NULL_RETURN_VALUE(result, EMF_ERROR_INVALID_PARAM);\r
 496 \r
 497         *result = FALSE;\r
 498 \r
 499         copy_of_subject = EM_SAFE_STRDUP(subject);\r
 500 \r
 501         if (copy_of_subject == NULL) {\r
 502                 EM_DEBUG_EXCEPTION("strdup is failed.");\r
 503                 goto FINISH_OFF;\r
 504         }\r
 505 \r
 506         em_upper_string(copy_of_subject);\r
 507         EM_DEBUG_LOG("em_upper_string result : %s\n", copy_of_subject);\r
 508 \r
 509         if (strstr(copy_of_subject, "RE:") == NULL) {\r
 510                 if (strstr(copy_of_subject, "FWD:") == NULL) {\r
 511                         if (strstr(copy_of_subject, "FW:") != NULL)\r
 512                                 *result = TRUE;\r
 513                 }\r
 514                 else\r
 515                         *result = TRUE;\r
 516         }\r
 517         else\r
 518                 *result = TRUE;\r
 519 \r
 520 FINISH_OFF:\r
 521         EM_SAFE_FREE(copy_of_subject);\r
 522 \r
 523         EM_DEBUG_FUNC_END("result : %d", *result);\r
 524 \r
 525         return error_code;\r
 526 }\r
 527 \r
 528 INTERNAL_FUNC int em_find_pos_stripped_subject_for_thread_view(char *subject, char *stripped_subject)\r
 529 {\r
 530         EM_DEBUG_FUNC_BEGIN();\r
 531         int error_code = EMF_ERROR_NONE;\r
 532         int gap;\r
 533         char *copy_of_subject = NULL, *curpos = NULL, *result;\r
 534 \r
 535         EM_IF_NULL_RETURN_VALUE(subject, EMF_ERROR_INVALID_PARAM);\r
 536         EM_IF_NULL_RETURN_VALUE(stripped_subject, EMF_ERROR_INVALID_PARAM);\r
 537 \r
 538         copy_of_subject = EM_SAFE_STRDUP(subject);\r
 539 \r
 540         if (copy_of_subject == NULL) {\r
 541                 EM_DEBUG_EXCEPTION("strdup is failed");\r
 542                 goto FINISH_OFF;\r
 543         }\r
 544 \r
 545         em_upper_string(copy_of_subject);\r
 546         curpos = copy_of_subject;\r
 547 \r
 548         EM_DEBUG_LOG("em_upper_string result : %s", copy_of_subject);\r
 549 \r
 550         while ((result = strstr(curpos, "RE:")) != NULL) {\r
 551                 curpos = result + 3;\r
 552                 EM_DEBUG_LOG("RE result : %s", curpos);\r
 553         }\r
 554 \r
 555         while ((result = strstr(curpos, "FWD:")) != NULL) {\r
 556                 curpos = result + 4;\r
 557                 EM_DEBUG_LOG("FWD result : %s", curpos);\r
 558         }\r
 559 \r
 560         while ((result = strstr(curpos, "FW:")) != NULL) {\r
 561                 curpos = result + 3;\r
 562                 EM_DEBUG_LOG("FW result : %s", curpos);\r
 563         }\r
 564 \r
 565         while (curpos != NULL && *curpos == ' ') {\r
 566                 curpos++;\r
 567         }\r
 568 \r
 569         gap = curpos - copy_of_subject;\r
 570 \r
 571         strcpy(stripped_subject, subject + gap);\r
 572 \r
 573 FINISH_OFF:\r
 574         EM_SAFE_FREE(copy_of_subject);\r
 575 \r
 576         if (error_code == EMF_ERROR_NONE && stripped_subject)\r
 577                 EM_DEBUG_LOG("result[%s]", stripped_subject);\r
 578 \r
 579         EM_DEBUG_FUNC_END("error_code[%d]", error_code);\r
 580         return error_code;\r
 581 }\r
 582 \r
 583 \r
 584 /*\r
 585  * encoding base64\r
 586  */\r
 587 INTERNAL_FUNC int em_encode_base64(char *src, unsigned long src_len, char **enc, unsigned long* enc_len, int *err_code)\r
 588 {\r
 589         EM_DEBUG_FUNC_BEGIN();\r
 590 \r
 591     unsigned char *content;\r
 592     int ret = true, err = EMF_ERROR_NONE;\r
 593 \r
 594         if (err_code != NULL) {\r
 595                 *err_code = EMF_ERROR_NONE;\r
 596         }\r
 597 \r
 598     content = rfc822_binary(src, src_len, enc_len);\r
 599 \r
 600     if (content)\r
 601         *enc = (char *)content;\r
 602     else {\r
 603         err = EMF_ERROR_UNKNOWN;\r
 604         ret = false;\r
 605     }\r
 606 \r
 607     if (err_code)\r
 608         *err_code = err;\r
 609 \r
 610         EM_DEBUG_FUNC_END();\r
 611     return ret;\r
 612 }\r
 613 \r
 614 /*\r
 615  * decoding base64\r
 616  */\r
 617 INTERNAL_FUNC int em_decode_base64(unsigned char *enc_text, unsigned long enc_len, char **dec_text, unsigned long* dec_len, int *err_code)\r
 618 {\r
 619     unsigned char *text = enc_text;\r
 620     unsigned long size = enc_len;\r
 621     unsigned char *content;\r
 622     int ret = true, err = EMF_ERROR_NONE;\r
 623 \r
 624         if (err_code != NULL) {\r
 625                 *err_code = EMF_ERROR_NONE;\r
 626         }\r
 627 \r
 628     EM_DEBUG_FUNC_BEGIN();\r
 629 \r
 630     content = rfc822_base64(text, size, dec_len);\r
 631     if (content)\r
 632         *dec_text = (char *)content;\r
 633     else\r
 634     {\r
 635         err = EMF_ERROR_UNKNOWN;\r
 636         ret = false;\r
 637     }\r
 638 \r
 639     if (err_code)\r
 640         *err_code = err;\r
 641 \r
 642     return ret;\r
 643 }\r