/* * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an AS IS BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #define EMAIL_API_ERROR_NONE 1 #define EMAIL_API_ERROR_OUT_OF_MEMORY -1028 #define EMAIL_API_ERROR_ACCOUNT_NOT_FOUND -1014 #undef EMAIL_ERROR_NONE #undef EMAIL_ERROR_OUT_OF_MEMORY #undef EMAIL_ERROR_ACCOUNT_NOT_FOUND #include #include #include #include #ifdef LOG_TAG #undef LOG_TAG #endif #define LOG_TAG "CAPI_EMAIL" #define DBG_MODE (1) #define EM_SAFE_STRDUP(s) \ ({\ char* _s = (char*)s;\ (_s)? strdup(_s) : NULL;\ }) typedef struct { email_message_sent_cb callback; email_s *handle; void *user_data; } email_cb_context; GSList *gEmailcbList= NULL; //------------- Utility Or Miscellaneous void _email_add_dbus_filter(void); int _email_error_converter(int err, const char *func, int line); int _email_copy_handle(email_s **dst_handle, email_s *src_handle); void _email_free_cb_context(email_cb_context *cbcontext); #define CONVERT_ERROR(err) _email_error_converter(err, __FUNCTION__, __LINE__); //------------------------------------ int email_create_message(email_h *msg) { int ret; email_s * msg_s = NULL; email_account_t* account = NULL; int len; if(msg == NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is NULL.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } // 1. create service for ipc ret=email_service_begin(); msg_s= (email_s*)calloc(1,sizeof(email_s)); if (msg_s != NULL) { msg_s->mail = (email_mail_data_t *)calloc(1,sizeof(email_mail_data_t)); if (msg_s->mail == NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create msg_s->mail", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); free(msg_s); return EMAIL_ERROR_OUT_OF_MEMORY; } msg_s->mbox = (email_mailbox_t *)calloc(1,sizeof(email_mailbox_t)); if (msg_s->mbox == NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create msg_s->mbox", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); free(msg_s); return EMAIL_ERROR_OUT_OF_MEMORY; } } else { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create msg_s", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } //return error from F/W //EMAIL_ERROR_INVALID_PARAM/EMAIL_API_ERROR_NONE/EMAIL_ERROR_DB_FAILURE/EMAIL_ERROR_ACCOUNT_NOT_FOUND/EMAIL_ERROR_OUT_OF_MEMORY int default_account_id = 0; if ((ret = email_load_default_account_id(&default_account_id)) != EMAIL_API_ERROR_NONE) { LOGE("[%s] email_load_default_account_id failed : [%d]",__FUNCTION__, ret); return CONVERT_ERROR(ret); } ret = email_get_account(default_account_id, GET_FULL_DATA, &account); if(ret!=EMAIL_API_ERROR_NONE) return CONVERT_ERROR(ret); LOGD_IF(DBG_MODE,"account address = %s",account->user_email_address); LOGD_IF(DBG_MODE,"account id = %d",account->account_id); LOGD_IF(DBG_MODE,"account name = %s",account->account_name); LOGD_IF(DBG_MODE,"account user_name = %s",account->incoming_server_user_name); msg_s->mail->full_address_from = (char *)calloc(1,sizeof(char)*(strlen(account->incoming_server_user_name)+strlen(account->user_email_address)+1+1+1+1+1));//"++"+<+ address +> + NULL len= (strlen(account->incoming_server_user_name)+strlen(account->user_email_address)+1+1+1+1+1); char *strfrom = msg_s->mail->full_address_from; snprintf(strfrom,len,"%s%s%s%s%s%s","\"",account->incoming_server_user_name,"\"","<",account->user_email_address,">"); //mbox email_mailbox_t *mbox =msg_s->mbox; if ( (ret = email_get_mailbox_by_mailbox_type(default_account_id, EMAIL_MAILBOX_TYPE_OUTBOX, &mbox)) != EMAIL_API_ERROR_NONE) { LOGE("[%s] email_get_mailbox_by_mailbox_type failed %d", __FUNCTION__, ret); return EMAIL_ERROR_DB_FAILED; } //info msg_s->mail->account_id = account->account_id; msg_s->mail->flags_draft_field = 1; msg_s->mail->flags_seen_field = 1; msg_s->mail->priority = EMAIL_MAIL_PRIORITY_NORMAL; msg_s->mail->mailbox_id = mbox->mailbox_id; msg_s->mail->mailbox_type = mbox->mailbox_type; msg_s->mail->attachment_count = 0; *msg = (email_h)msg_s; return EMAIL_ERROR_NONE; } int email_destroy_message(email_h msg) { int ret; if(msg == NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is NULL.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s* msg_s = (email_s* )msg; if(msg_s) { if (msg_s->mail) email_free_mail_data(&msg_s->mail, 1); if (msg_s->mbox) email_free_mailbox(&msg_s->mbox, 1); free(msg_s); } ret=email_service_end(); if(ret!=EMAIL_API_ERROR_NONE){ LOGE("[%s] OPERATION_FAILED(0x%08x) : Finishing email service failed", __FUNCTION__, EMAIL_ERROR_OPERATION_FAILED); return EMAIL_ERROR_OPERATION_FAILED; } return EMAIL_ERROR_NONE; } int email_set_subject (email_h msg, const char *subject) { int len; if(msg ==NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is NULL", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s* msg_s = (email_s* )msg; msg_s->mail->subject=(char*)calloc(1,sizeof(char)*strlen(subject)+1); if(msg_s->mail->subject ==NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create msg_s->mail->head->subject", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } len =strlen(subject)+1; snprintf(msg_s->mail->subject ,len,"%s",subject); return EMAIL_ERROR_NONE; } int email_set_body (email_h msg, const char *body) { int len; if (msg == NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is null.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s* msg_s = (email_s* )msg; FILE* file = NULL; file = fopen("/tmp/capimail.txt", "w"); if (file != NULL) { fputs(body, file); fclose(file); } else { LOGE("[%s] OPERATION_FAILED(0x%08x) : opening file for email body failed.", __FUNCTION__, EMAIL_ERROR_OPERATION_FAILED); return EMAIL_ERROR_OPERATION_FAILED; } msg_s->mail->file_path_plain =(char *)calloc(1,sizeof(char)*strlen("/tmp/capimail.txt")+1); if(msg_s->mail->file_path_plain == NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to allocate body(plain).", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } len =strlen("/tmp/capimail.txt")+1; snprintf(msg_s->mail->file_path_plain,len,"%s","/tmp/capimail.txt"); return EMAIL_ERROR_NONE; } int email_add_recipient (email_h msg, email_recipient_type_e type, const char *address) { char *tmp; int total_len,in_len,pre_len,len; if(msg == NULL || type < EMAIL_RECIPIENT_TYPE_TO || type > EMAIL_RECIPIENT_TYPE_BCC ) { return EMAIL_ERROR_INVALID_PARAMETER; } email_s* msg_s = (email_s* )msg; if(strlen(address) > MAX_RECIPIENT_ADDRESS_LEN) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : The length of address should be less than 234.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } if(type == EMAIL_RECIPIENT_TYPE_TO) { if(msg_s->mail->full_address_to == NULL) { msg_s->mail->full_address_to = (char*)calloc(1,sizeof(char)*strlen(address)+2+1+1);//<>+;+end of string if(msg_s->mail->full_address_to == NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create head->to.", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } len =strlen(address)+2+1+1; snprintf(msg_s->mail->full_address_to,len,"%s%s%s","<",address,">"); } else { in_len = strlen(address); pre_len = strlen(msg_s->mail->full_address_to); total_len = pre_len+in_len+3+1;// length of ",<>" + NULL //add new address tmp = msg_s->mail->full_address_to; msg_s->mail->full_address_to = (char*)calloc(1,sizeof(char)*total_len); snprintf(msg_s->mail->full_address_to,total_len,"%s%s%s%s",tmp,",<",address,">"); free(tmp); } } else if(type == EMAIL_RECIPIENT_TYPE_CC)//MESSAGING_RECIPIENT_TYPE_CC { if(msg_s->mail->full_address_cc == NULL) { msg_s->mail->full_address_cc = (char*)calloc(1,sizeof(char)*strlen(address)+2+1+1);//<>+;+end of string if(msg_s->mail->full_address_cc == NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create head->cc.", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } len =strlen(address)+2+1+1; snprintf(msg_s->mail->full_address_cc,len,"%s%s%s","<",address,">"); } else { in_len = strlen(address); pre_len = strlen(msg_s->mail->full_address_cc); total_len = pre_len+in_len+3+1;// length of ",<>" + NULL //add new address tmp = msg_s->mail->full_address_cc; msg_s->mail->full_address_cc = (char*)calloc(1,sizeof(char)*total_len); snprintf(msg_s->mail->full_address_cc,total_len,"%s%s%s%s",tmp,",<",address,">"); free(tmp); } } else //MESSAGING_RECIPIENT_TYPE_BCC { if(msg_s->mail->full_address_bcc == NULL) { msg_s->mail->full_address_bcc = (char*)calloc(1,sizeof(char)*strlen(address)+2+1+1);//<>+;+end of string if(msg_s->mail->full_address_bcc==NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create head->bcc.", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } len =strlen(address)+2+1+1; snprintf(msg_s->mail->full_address_bcc,len,"%s%s%s","<",address,">"); } else{ in_len = strlen(address); pre_len = strlen(msg_s->mail->full_address_bcc); total_len = pre_len+in_len+3+1;// length of ",<>" + NULL //add new address tmp = msg_s->mail->full_address_bcc; msg_s->mail->full_address_bcc = (char*)calloc(1,sizeof(char)*total_len); snprintf(msg_s->mail->full_address_bcc,total_len,"%s%s%s%s",tmp,",<",address,">"); free(tmp); } } return EMAIL_ERROR_NONE; } int email_remove_all_recipients(email_h msg) { if(msg ==NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : fail to create tmp memory.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s *msg_s = (email_s *)msg; if(msg_s->mail->full_address_to != NULL) { free(msg_s->mail->full_address_to); msg_s->mail->full_address_to = NULL; } if(msg_s->mail->full_address_cc != NULL) { free(msg_s->mail->full_address_cc); msg_s->mail->full_address_cc = NULL; } if(msg_s->mail->full_address_bcc != NULL) { free(msg_s->mail->full_address_bcc); msg_s->mail->full_address_bcc = NULL; } return EMAIL_ERROR_NONE; } int email_add_attach (email_h msg, const char *filepath) { int len; char *pos,*last; struct stat st; if(msg ==NULL || filepath == NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg or filepath is null.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s *msg_s = (email_s *)msg; int attachment_count = msg_s->mail->attachment_count; email_attachment_data_t *new_attach = msg_s->attachment; stat(filepath, &st); if(st.st_size > 10*1024*1024) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : the size of attachment file is beyond the limit(MAX:10M).", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } if (!S_ISREG(st.st_mode)) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : the filepath is not regular file.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } pos=strpbrk(filepath, "//"); len =strlen(filepath); if(pos == NULL) { new_attach[attachment_count].attachment_name = (char*)calloc(1,sizeof(char)*len+1); snprintf(new_attach[attachment_count].attachment_name,len+1,"%s",filepath); } else { while(pos != NULL) { last=pos; pos=strpbrk(pos,"//"); if(pos != NULL) pos++; } new_attach[attachment_count].attachment_name =last; } new_attach[attachment_count].attachment_path =(char*)calloc(1,sizeof(char)*len+1); if (new_attach[attachment_count].attachment_path == NULL) return EMAIL_ERROR_OUT_OF_MEMORY; snprintf(new_attach[attachment_count].attachment_path, len+1, "%s", filepath); new_attach[attachment_count].attachment_size = st.st_size; new_attach[attachment_count].save_status = 1; msg_s->mail->attachment_count++; return EMAIL_ERROR_NONE; } int email_remove_all_attachments (email_h msg) { if (msg ==NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is null.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s* msg_s = (email_s* )msg; msg_s->mail->attachment_count = 0; return EMAIL_ERROR_NONE; } int email_send_message (email_h msg, bool save_to_sentbox) { int i, ret; email_option_t option; unsigned handle; email_attachment_data_t *tmp_attach = NULL; struct tm *struct_time; if (msg == NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is null.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s *msg_s = (email_s *)msg; { /*--------- head ----------*/ LOGD_IF(DBG_MODE, " ----------head---------"); LOGD_IF(DBG_MODE, " mid: %s\n",msg_s->mail->message_id); LOGD_IF(DBG_MODE, " subject: %s\n",msg_s->mail->subject); LOGD_IF(DBG_MODE, " to: %s\n",msg_s->mail->full_address_to); LOGD_IF(DBG_MODE, " from: %s\n",msg_s->mail->full_address_from); LOGD_IF(DBG_MODE, " cc: %s\n",msg_s->mail->full_address_cc); LOGD_IF(DBG_MODE, " bcc: %s\n",msg_s->mail->full_address_bcc); LOGD_IF(DBG_MODE, " reply_to: %s\n",msg_s->mail->full_address_reply); LOGD_IF(DBG_MODE, " return_path: %s\n",msg_s->mail->full_address_return); LOGD_IF(DBG_MODE, " previewBodyText: %s\n",msg_s->mail->preview_text); struct_time = localtime(&msg_s->mail->date_time); LOGD_IF(DBG_MODE, " %4d year\n", struct_time->tm_year+1900); LOGD_IF(DBG_MODE, " %2d month\n", struct_time->tm_mon+1); LOGD_IF(DBG_MODE, " %2d day\n", struct_time->tm_mday); LOGD_IF(DBG_MODE, " %2d:%2d:%2d \n", struct_time->tm_hour, struct_time->tm_min, struct_time->tm_sec); /*--------- body ----------*/ LOGD_IF(DBG_MODE, " ----------body---------"); LOGD_IF(DBG_MODE, " body\n"); LOGD_IF(DBG_MODE, " plain: %s\n",msg_s->mail->file_path_plain); LOGD_IF(DBG_MODE, " html: %s\n",msg_s->mail->file_path_html); LOGD_IF(DBG_MODE, " attachment_num: %d\n",msg_s->mail->attachment_count); tmp_attach = msg_s->attachment; for (i=0; i < msg_s->mail->attachment_count; i++) { LOGD_IF(DBG_MODE, " ----------attachment[%d]---------", i+1); LOGD_IF(DBG_MODE, " name: %s\n",tmp_attach[i].attachment_name); LOGD_IF(DBG_MODE, " savename: %s\n",tmp_attach[i].attachment_path); LOGD_IF(DBG_MODE, " downloaded: %d\n",tmp_attach[i].save_status); LOGD_IF(DBG_MODE, " size: %d\n",tmp_attach[i].attachment_size); } } { /*--------- info ----------*/ LOGD_IF(DBG_MODE, " ----------info---------"); LOGD_IF(DBG_MODE, " account_id: %d\n",msg_s->mail->account_id); LOGD_IF(DBG_MODE, " mail_id: %d\n",msg_s->mail->mail_id); LOGD_IF(DBG_MODE, " mail_size: %d\n",msg_s->mail->mail_size); LOGD_IF(DBG_MODE, " body_download_status: %d\n",msg_s->mail->body_download_status); LOGD_IF(DBG_MODE, " server_id: %s\n",msg_s->mail->server_mail_id); LOGD_IF(DBG_MODE, " meeting_request_status: %d\n",msg_s->mail->meeting_request_status); } { email_mailbox_t * box; box=msg_s->mbox; LOGD_IF(DBG_MODE, " ----------box---------"); LOGD_IF(DBG_MODE, " email_mailbox_t \n"); LOGD_IF(DBG_MODE, " name: %s\n",box->mailbox_name); LOGD_IF(DBG_MODE, " mailbox_type: %d\n",box->mailbox_type); LOGD_IF(DBG_MODE, " alias: %s\n",box->alias); LOGD_IF(DBG_MODE, " unread_count: %d\n",box->unread_count); LOGD_IF(DBG_MODE, " total_mail_count_on_local: %d\n",box->total_mail_count_on_local); LOGD_IF(DBG_MODE, " total_mail_count_on_server: %d\n",box->total_mail_count_on_server); LOGD_IF(DBG_MODE, " local: %d\n",box->local); LOGD_IF(DBG_MODE, " account_id: %d\n",box->account_id); LOGD_IF(DBG_MODE, " mail_slot_size: %d\n",box->mail_slot_size); } ret=email_add_mail(msg_s->mail, msg_s->attachment, msg_s->mail->attachment_count, NULL, 0); ret=CONVERT_ERROR(ret); memset(&option, 0x00, sizeof(email_option_t)); option.keep_local_copy = save_to_sentbox ? 1 : 0; ret=email_send_mail(msg_s->mail->mail_id, &option, &handle); ret=CONVERT_ERROR(ret); _email_add_dbus_filter(); return ret; } email_cb_context * _email_search_callback_by_emailid(int mailid) { int count; int ntmp=0; GSList * node; email_cb_context *cbContext; count = g_slist_length( gEmailcbList ); while( count ) { node = g_slist_nth( gEmailcbList, ntmp ); if( node == NULL ) break; cbContext= (email_cb_context *)node->data; if(cbContext->handle->mail->mail_id == mailid) { return cbContext; } ntmp++; count--; } return NULL; } int email_set_message_sent_cb (email_h handle, email_message_sent_cb cb, void *user_data) { int count; int ntmp=0; int ret = EMAIL_ERROR_NONE; GSList * node; email_cb_context *cbContext; count = g_slist_length( gEmailcbList ); if(handle ==NULL || cb == NULL)return EMAIL_ERROR_INVALID_PARAMETER; email_s* msg_s = NULL; while( count ) { node = g_slist_nth( gEmailcbList, ntmp ); if( node == NULL ) break; cbContext= (email_cb_context *)node->data; if(cbContext->handle == (email_s*)handle) { gEmailcbList=g_slist_remove(gEmailcbList,node); _email_free_cb_context(cbContext); break; } ntmp++; count--; } if ((ret = _email_copy_handle(&msg_s, (email_s *)handle)) != EMAIL_ERROR_NONE) { LOGE("[%s] _email_copy_handle failed", __FUNCTION__); return ret; } email_cb_context * cbcontext= (email_cb_context*)calloc(1, sizeof(email_cb_context) ); cbcontext->handle = msg_s; cbcontext->callback=cb; cbcontext->user_data =user_data; gEmailcbList = g_slist_append(gEmailcbList,cbcontext); return EMAIL_ERROR_NONE; } int email_unset_message_sent_cb (email_h msg) { int i,count; count = g_slist_length( gEmailcbList ); GSList * node; email_cb_context *cbContext; if(msg ==NULL ) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is null.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return EMAIL_ERROR_INVALID_PARAMETER; } email_s* msg_s = (email_s* )msg; for( i=0;idata; if(cbContext->handle == msg_s) { gEmailcbList= g_slist_remove(gEmailcbList,node); _email_free_cb_context(cbContext); break; } } return EMAIL_ERROR_NONE; } int _email_error_converter(int err, const char *func, int line) { switch(err) { case EMAIL_ERROR_INVALID_PARAM : LOGE("[%s:%d] INVALID_PARAM(0x%08x) : Error from Email F/W. ret: (0x%08x) ", func, line, EMAIL_ERROR_INVALID_PARAMETER, err); return EMAIL_ERROR_INVALID_PARAMETER; case EMAIL_ERROR_DB_FAILURE : LOGE("[%s:%d] DB_FAILURE(0x%08x) : Error from Email F/W. ret: (0x%08x) ", func, line, EMAIL_ERROR_DB_FAILED, err); return EMAIL_ERROR_DB_FAILED; case EMAIL_API_ERROR_ACCOUNT_NOT_FOUND : LOGE("[%s:%d] ACCOUNT_NOT_FOUND(0x%08x) : Error from Email F/W. ret: (0x%08x) ", func, line, EMAIL_ERROR_ACCOUNT_NOT_FOUND,err); return EMAIL_ERROR_ACCOUNT_NOT_FOUND; case EMAIL_API_ERROR_OUT_OF_MEMORY : LOGE("[%s:%d] OUT_OF_MEMORY(0x%08x) : Error from Email F/W. ret: (0x%08x) ", func, line, EMAIL_ERROR_OUT_OF_MEMORY,err); return EMAIL_ERROR_OUT_OF_MEMORY; // Tizen email F/W is often using this error type when it gets a null value from server //It could be caused from server or IPC. case EMAIL_ERROR_NULL_VALUE : LOGE("[%s:%d] NULL_VALUE(0x%08x) : Error from Email F/W. ret: (0x%08x) ", func, line, EMAIL_ERROR_COMMUNICATION_WITH_SERVER_FAILED,err); return EMAIL_ERROR_COMMUNICATION_WITH_SERVER_FAILED; case EMAIL_ERROR_IPC_SOCKET_FAILURE : LOGE("[%s:%d] IPC_SOCKET_FAILURE(0x%08x) : Error from Email F/W. ret: (0x%08x) ", func, line, EMAIL_ERROR_COMMUNICATION_WITH_SERVER_FAILED,err); return EMAIL_ERROR_COMMUNICATION_WITH_SERVER_FAILED; case EMAIL_API_ERROR_NONE : return EMAIL_ERROR_NONE; default : LOGE("[%s:%d] OPERATION_FAILED(0x%08x) : Error from Email F/W. ret: (0x%08x) ", func, line, EMAIL_ERROR_OPERATION_FAILED,err); return EMAIL_ERROR_OPERATION_FAILED; } } static void _monitorSendStatusCb(void* data, DBusMessage *message) { DBusError error; email_cb_context *cbContext = NULL; if(dbus_message_is_signal(message, "User.Email.NetworkStatus", "email")) { dbus_error_init(&error); int status=0; int accountid=0; char* fileid=NULL; int mailid=0; int errorcode=0; if(dbus_message_get_args(message, &error, DBUS_TYPE_INT32, &status, DBUS_TYPE_INT32, &accountid, DBUS_TYPE_STRING, &fileid, DBUS_TYPE_INT32, &mailid, DBUS_TYPE_INT32, &errorcode, DBUS_TYPE_INVALID)) { cbContext = _email_search_callback_by_emailid(mailid); if(cbContext == NULL) { LOGD_IF(DBG_MODE, "no callback matched!\n"); }else{ switch (status) { case NOTI_SEND_START: break; case NOTI_SEND_FAIL: switch(errorcode) { case EMAIL_ERROR_NO_SIM_INSERTED: case EMAIL_ERROR_FLIGHT_MODE: case EMAIL_ERROR_SMTP_SEND_FAILURE: case EMAIL_ERROR_NO_SUCH_HOST: case EMAIL_ERROR_CONNECTION_FAILURE: case EMAIL_ERROR_CONNECTION_BROKEN: case EMAIL_ERROR_INVALID_SERVER: case EMAIL_ERROR_NO_RESPONSE: break; default: break; } cbContext->callback((email_h)cbContext->handle,(email_sending_e)EMAIL_SENDING_FAILED ,cbContext->user_data); break; case NOTI_SEND_FINISH: cbContext->callback((email_h)cbContext->handle,(email_sending_e)EMAIL_SENDING_SUCCEEDED ,cbContext->user_data); break; } } } } } void _email_add_dbus_filter(void) { E_DBus_Connection* connection=NULL; DBusError error; E_DBus_Signal_Handler *handler = NULL; dbus_error_init(&error); connection = e_dbus_bus_get(DBUS_BUS_SYSTEM); if (NULL == connection) { } if(e_dbus_request_name(connection, "User.Email.NetworkStatus", 0, NULL, NULL) == NULL) { LOGD_IF(DBG_MODE, "Failed in e_dbus_request_name()\n"); } handler = e_dbus_signal_handler_add(connection, NULL, "/User/Email/NetworkStatus", "User.Email.NetworkStatus", "email", _monitorSendStatusCb, NULL); if(handler == NULL) { LOGD_IF(DBG_MODE, "Failed in e_dbus_signal_handler_add()"); } } int _email_copy_mail_data(email_mail_data_t **dst_mail_data, email_mail_data_t *src_mail_data) { email_mail_data_t *temp_mail_data = NULL; temp_mail_data = (email_mail_data_t *)calloc(1, sizeof(email_mail_data_t)); if (temp_mail_data == NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create email_mail_data_t", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } temp_mail_data->mail_id = src_mail_data->mail_id; temp_mail_data->account_id = src_mail_data->account_id; temp_mail_data->mailbox_id = src_mail_data->mailbox_id; temp_mail_data->mailbox_type = src_mail_data->mailbox_type; temp_mail_data->subject = EM_SAFE_STRDUP(src_mail_data->subject); temp_mail_data->date_time = src_mail_data->date_time; temp_mail_data->server_mail_status = src_mail_data->server_mail_status; temp_mail_data->server_mailbox_name = EM_SAFE_STRDUP(src_mail_data->server_mailbox_name); temp_mail_data->server_mail_id = EM_SAFE_STRDUP(src_mail_data->server_mail_id); temp_mail_data->message_id = EM_SAFE_STRDUP(src_mail_data->message_id); temp_mail_data->full_address_from = EM_SAFE_STRDUP(src_mail_data->full_address_from); temp_mail_data->full_address_reply = EM_SAFE_STRDUP(src_mail_data->full_address_reply); temp_mail_data->full_address_to = EM_SAFE_STRDUP(src_mail_data->full_address_to); temp_mail_data->full_address_cc = EM_SAFE_STRDUP(src_mail_data->full_address_cc); temp_mail_data->full_address_bcc = EM_SAFE_STRDUP(src_mail_data->full_address_bcc); temp_mail_data->full_address_return = EM_SAFE_STRDUP(src_mail_data->full_address_return); temp_mail_data->email_address_sender = EM_SAFE_STRDUP(src_mail_data->email_address_sender); temp_mail_data->email_address_recipient = EM_SAFE_STRDUP(src_mail_data->email_address_recipient); temp_mail_data->alias_sender = EM_SAFE_STRDUP(src_mail_data->alias_sender); temp_mail_data->alias_recipient = EM_SAFE_STRDUP(src_mail_data->alias_recipient); temp_mail_data->body_download_status = src_mail_data->body_download_status; temp_mail_data->file_path_plain = EM_SAFE_STRDUP(src_mail_data->file_path_plain); temp_mail_data->file_path_html = EM_SAFE_STRDUP(src_mail_data->file_path_html); temp_mail_data->file_path_mime_entity = EM_SAFE_STRDUP(src_mail_data->file_path_mime_entity); temp_mail_data->mail_size = src_mail_data->mail_size; temp_mail_data->flags_seen_field = src_mail_data->flags_seen_field; temp_mail_data->flags_deleted_field = src_mail_data->flags_deleted_field; temp_mail_data->flags_flagged_field = src_mail_data->flags_flagged_field; temp_mail_data->flags_answered_field = src_mail_data->flags_answered_field; temp_mail_data->flags_recent_field = src_mail_data->flags_recent_field; temp_mail_data->flags_draft_field = src_mail_data->flags_draft_field; temp_mail_data->flags_forwarded_field = src_mail_data->flags_forwarded_field; temp_mail_data->DRM_status = src_mail_data->DRM_status; temp_mail_data->priority = src_mail_data->priority; temp_mail_data->save_status = src_mail_data->save_status; temp_mail_data->lock_status = src_mail_data->lock_status; temp_mail_data->report_status = src_mail_data->report_status; temp_mail_data->attachment_count = src_mail_data->attachment_count; temp_mail_data->inline_content_count = src_mail_data->inline_content_count; temp_mail_data->thread_id = src_mail_data->thread_id; temp_mail_data->thread_item_count = src_mail_data->thread_item_count; temp_mail_data->preview_text = EM_SAFE_STRDUP(src_mail_data->preview_text); temp_mail_data->meeting_request_status = src_mail_data->meeting_request_status; temp_mail_data->message_class = src_mail_data->message_class; temp_mail_data->digest_type = src_mail_data->digest_type; temp_mail_data->smime_type = src_mail_data->smime_type; *dst_mail_data = temp_mail_data; return EMAIL_ERROR_NONE; } int _email_copy_mailbox(email_mailbox_t **dst_mailbox, email_mailbox_t *src_mailbox) { email_mailbox_t *temp_mailbox = NULL; temp_mailbox = (email_mailbox_t *)calloc(1,sizeof(email_mailbox_t)); if (temp_mailbox == NULL) { LOGE("[%s] OUT_OF_MEMORY(0x%08x) : fail to create mailbox", __FUNCTION__, EMAIL_ERROR_OUT_OF_MEMORY); return EMAIL_ERROR_OUT_OF_MEMORY; } temp_mailbox->mailbox_id = src_mailbox->mailbox_id; temp_mailbox->mailbox_name = EM_SAFE_STRDUP(src_mailbox->mailbox_name); temp_mailbox->mailbox_type = src_mailbox->mailbox_type; temp_mailbox->alias = EM_SAFE_STRDUP(src_mailbox->alias); temp_mailbox->unread_count = src_mailbox->unread_count; temp_mailbox->total_mail_count_on_local = src_mailbox->total_mail_count_on_local; temp_mailbox->total_mail_count_on_server = src_mailbox->total_mail_count_on_server; temp_mailbox->local = src_mailbox->local; temp_mailbox->account_id = src_mailbox->account_id; temp_mailbox->mail_slot_size = src_mailbox->mail_slot_size; temp_mailbox->last_sync_time = src_mailbox->last_sync_time; *dst_mailbox = temp_mailbox; return EMAIL_ERROR_NONE; } int _email_copy_handle(email_s **dst_handle, email_s *src_handle) { int ret = EMAIL_ERROR_NONE; email_s *msg_s = NULL; msg_s = (email_s *)calloc(1,sizeof(email_s)); if ((ret = _email_copy_mail_data(&msg_s->mail, src_handle->mail)) != EMAIL_ERROR_NONE) { LOGE("[%s] _email_copy_mail_data failed", __FUNCTION__); return ret; } if ((ret = _email_copy_mailbox(&msg_s->mbox, src_handle->mbox)) != EMAIL_ERROR_NONE) { LOGE("[%s] _email_copy_mailbox failed", __FUNCTION__); return ret; } *dst_handle = msg_s; return ret; } void _email_free_cb_context(email_cb_context *cbcontext) { if(cbcontext == NULL) { LOGE("[%s] INVALID_PARAMETER(0x%08x) : msg is NULL.", __FUNCTION__, EMAIL_ERROR_INVALID_PARAMETER); return; } email_s* msg_s = cbcontext->handle; if(msg_s) { if (msg_s->mail) email_free_mail_data(&msg_s->mail, 1); if (msg_s->mbox) email_free_mailbox(&msg_s->mbox, 1); free(msg_s); } cbcontext = NULL; }