Coverity fix: check return type
[platform/core/messaging/msg-service.git] / mapi / msg_svc.cpp
1 /*
2  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15 */
16
17 #include <string.h>
18
19 #include "MsgDebug.h"
20 #include "MsgTypes.h"
21 #include "MsgHandle.h"
22 #include "MsgTextConvert.h"
23 #include "MsgException.h"
24 #include "MsgMemory.h"
25
26 #include "msg_private.h"
27 #include "msg.h"
28
29 void __msg_release_list_item(gpointer data)
30 {
31         if (data == NULL)
32                 return;
33
34         msg_release_struct((msg_struct_t*)(&data));
35 }
36
37
38 EXPORT_API msg_struct_t msg_create_struct(int field)
39 {
40         CHECK_MSG_SUPPORTED_RETURN_NULL(MSG_TELEPHONY_SMS_FEATURE);
41         msg_struct_s *msg_struct = new msg_struct_s;
42         memset(msg_struct, 0x00, sizeof(msg_struct_s));
43
44         msg_struct->type = field;
45         msg_struct->data = NULL;
46
47         switch (field) {
48         case MSG_STRUCT_MESSAGE_INFO:
49                 msg_message_create_struct(msg_struct);
50                 break;
51         case MSG_STRUCT_CONV_INFO: {
52                 msg_struct->data = (void *)new MSG_CONVERSATION_VIEW_S;
53                 memset(msg_struct->data, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
54                 break;
55         }
56         case MSG_STRUCT_FILTER: {
57                 msg_struct->data = (void *)new MSG_FILTER_S;
58                 memset(msg_struct->data, 0x00, sizeof(MSG_FILTER_S));
59                 break;
60         }
61         case MSG_STRUCT_THREAD_INFO: {
62                 msg_struct->data = (void *)new MSG_THREAD_VIEW_S;
63                 memset(msg_struct->data, 0x00, sizeof(MSG_THREAD_VIEW_S));
64                 break;
65         }
66         case MSG_STRUCT_SENDOPT: {
67                 MSG_SENDINGOPT_S *pOpt = (MSG_SENDINGOPT_S *)new MSG_SENDINGOPT_S;
68                 memset(pOpt, 0x00, sizeof(MSG_SENDINGOPT_S));
69                 msg_struct->data = pOpt;
70
71                 msg_struct_s *pSms = new msg_struct_s;
72                 msg_struct_s *pMms = new msg_struct_s;
73
74                 pOpt->mmsSendOpt = (msg_struct_t)pMms;
75                 pOpt->smsSendOpt = (msg_struct_t)pSms;
76
77                 pMms->type = MSG_STRUCT_MMS_SENDOPT;
78                 pMms->data = new MMS_SENDINGOPT_S;
79                 memset(pMms->data, 0x00, sizeof(MMS_SENDINGOPT_S));
80
81                 pSms->type = MSG_STRUCT_SMS_SENDOPT;
82                 pSms->data = new SMS_SENDINGOPT_S;
83                 memset(pSms->data, 0x00, sizeof(SMS_SENDINGOPT_S));
84                 break;
85         }
86         case MSG_STRUCT_SYNCML_INFO: {
87                 MSG_SYNCML_MESSAGE_S *pSyncML = (MSG_SYNCML_MESSAGE_S *)new MSG_SYNCML_MESSAGE_S;
88                 memset(pSyncML, 0x00, sizeof(MSG_SYNCML_MESSAGE_S));
89                 msg_struct->data = pSyncML;
90
91                 msg_struct_s *pStruct = new msg_struct_s;
92                 pSyncML->msg = (msg_struct_t)pStruct;
93                 pStruct->type = MSG_STRUCT_MESSAGE_INFO;
94                 msg_message_create_struct(pStruct);
95
96                 break;
97         }
98         case MSG_STRUCT_COUNT_INFO: {
99                 msg_struct->data = new MSG_COUNT_INFO_S;
100                 memset(msg_struct->data, 0x00, sizeof(MSG_COUNT_INFO_S));
101                 break;
102         }
103         case MSG_STRUCT_THREAD_COUNT_INFO: {
104                 msg_struct->data = new MSG_THREAD_COUNT_INFO_S;
105                 memset(msg_struct->data, 0x00, sizeof(MSG_THREAD_COUNT_INFO_S));
106                 break;
107         }
108         case MSG_STRUCT_THREAD_LIST_INDEX: {
109                 MSG_THREAD_LIST_INDEX_INFO_S * pThread = (MSG_THREAD_LIST_INDEX_INFO_S *)new MSG_THREAD_LIST_INDEX_INFO_S;
110                 memset(pThread, 0x00, sizeof(MSG_THREAD_LIST_INDEX_INFO_S));
111
112                 msg_struct->data = (void *)pThread;
113
114                 msg_struct_s *pStruct = new msg_struct_s;
115                 pThread->msgAddrInfo = (msg_struct_t)pStruct;
116
117                 pStruct->type = MSG_STRUCT_ADDRESS_INFO;
118                 pStruct->data = new MSG_ADDRESS_INFO_S;
119                 memset(pStruct->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
120
121                 break;
122         }
123         case MSG_STRUCT_SORT_RULE: {
124                 msg_struct->data = new MSG_SORT_RULE_S;
125                 memset(msg_struct->data, 0x00, sizeof(MSG_SORT_RULE_S));
126                 break;
127         }
128         case MSG_STRUCT_FOLDER_INFO: {
129                 msg_struct->data = new MSG_FOLDER_INFO_S;
130                 memset(msg_struct->data, 0x00, sizeof(MSG_FOLDER_INFO_S));
131                 break;
132         }
133         case MSG_STRUCT_MSG_LIST_CONDITION: {
134                 msg_struct->data = new MSG_LIST_CONDITION_S;
135                 memset(msg_struct->data, 0x00, sizeof(MSG_LIST_CONDITION_S));
136
137                 msg_struct_s *pStruct = new msg_struct_s;
138                 ((MSG_LIST_CONDITION_S *)msg_struct->data)->sortRule = (msg_struct_t)pStruct;
139
140                 pStruct->type = MSG_STRUCT_SORT_RULE;
141                 pStruct->data = new MSG_SORT_RULE_S;
142                 memset(pStruct->data, 0x00, sizeof(MSG_SORT_RULE_S));
143
144                 break;
145         }
146         case MSG_STRUCT_REPORT_STATUS_INFO: {
147                 msg_struct->data = new MSG_REPORT_STATUS_INFO_S;
148                 memset(msg_struct->data, 0x00, sizeof(MSG_REPORT_STATUS_INFO_S));
149                 break;
150         }
151         case MSG_STRUCT_SETTING_SMSC_OPT: {
152                 msg_struct->data = new MSG_SMSC_LIST_HIDDEN_S;
153                 memset(msg_struct->data, 0x00, sizeof(MSG_SMSC_LIST_HIDDEN_S));
154
155                 MSG_SMSC_LIST_HIDDEN_S *pTmp = (MSG_SMSC_LIST_HIDDEN_S *)msg_struct->data;
156                 pTmp->simIndex = MSG_SIM_SLOT_ID_1; /* default sim index */
157
158                 msg_struct_list_s *smsc_list = (msg_struct_list_s *)new msg_struct_list_s;
159                 memset(smsc_list, 0x00, sizeof(msg_struct_list_s));
160
161                 pTmp->smsc_list = smsc_list;
162
163                 smsc_list->msg_struct_info = (msg_struct_t *)calloc(SMSC_LIST_MAX, sizeof(msg_struct_t));
164
165                 if (smsc_list->msg_struct_info != NULL) {
166                         msg_struct_s *pStructTmp = NULL;
167
168                         for (int i = 0; i < SMSC_LIST_MAX; i++) {
169                                 pStructTmp = (msg_struct_s *)new msg_struct_s;
170                                 pStructTmp->type = MSG_STRUCT_SETTING_SMSC_INFO;
171                                 pStructTmp->data = new MSG_SMSC_DATA_S;
172                                 memset(pStructTmp->data, 0x00, sizeof(MSG_SMSC_DATA_S));
173                                 smsc_list->msg_struct_info[i] = (msg_struct_t)pStructTmp;
174                         }
175                 }
176                 break;
177         }
178         case MSG_STRUCT_SETTING_SMSC_INFO: {
179                 msg_struct->data = new MSG_SMSC_DATA_S;
180                 memset(msg_struct->data, 0x00, sizeof(MSG_SMSC_DATA_S));
181                 break;
182         }
183         case MSG_STRUCT_SETTING_CB_OPT: {
184                 msg_struct->data = new MSG_CBMSG_OPT_HIDDEN_S;
185                 memset(msg_struct->data, 0x00, sizeof(MSG_CBMSG_OPT_HIDDEN_S));
186
187                 MSG_CBMSG_OPT_HIDDEN_S *pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)msg_struct->data;
188                 pTmp->simIndex = MSG_SIM_SLOT_ID_1; /* default sim index */
189
190                 pTmp->channelData = (msg_struct_list_s *)new msg_struct_list_s;
191                 memset(pTmp->channelData, 0x00, sizeof(msg_struct_list_s));
192
193                 pTmp->channelData->msg_struct_info = (msg_struct_t *)calloc(CB_CHANNEL_MAX, sizeof(msg_struct_t));
194
195                 if (pTmp->channelData->msg_struct_info != NULL) {
196                         msg_struct_s *pStructTmp = NULL;
197
198                         for (int i = 0; i < CB_CHANNEL_MAX; i++) {
199                                 pStructTmp = (msg_struct_s *)new msg_struct_s;
200                                 pStructTmp->type = MSG_STRUCT_SETTING_CB_CHANNEL_INFO;
201                                 pStructTmp->data = new MSG_CB_CHANNEL_INFO_S;
202
203                                 memset(pStructTmp->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
204                                 pTmp->channelData->msg_struct_info[i] = (msg_struct_t)pStructTmp;
205                         }
206                 }
207                 break;
208         }
209         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO: {
210                 msg_struct->data = new MSG_CB_CHANNEL_INFO_S;
211                 memset(msg_struct->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
212                 break;
213         }
214         case MSG_STRUCT_SETTING_SMS_SEND_OPT: {
215                 msg_struct->data = new MSG_SMS_SENDOPT_S;
216                 memset(msg_struct->data, 0x00, sizeof(MSG_SMS_SENDOPT_S));
217                 break;
218         }
219         case MSG_STRUCT_SETTING_MMS_SEND_OPT: {
220                 msg_struct->data = new MSG_MMS_SENDOPT_S;
221                 memset(msg_struct->data, 0x00, sizeof(MSG_MMS_SENDOPT_S));
222                 break;
223         }
224         case MSG_STRUCT_SETTING_MMS_RECV_OPT: {
225                 msg_struct->data = new MSG_MMS_RECVOPT_S;
226                 memset(msg_struct->data, 0x00, sizeof(MSG_MMS_RECVOPT_S));
227                 break;
228         }
229         case MSG_STRUCT_SETTING_PUSH_MSG_OPT: {
230                 msg_struct->data = new MSG_PUSHMSG_OPT_S;
231                 memset(msg_struct->data, 0x00, sizeof(MSG_PUSHMSG_OPT_S));
232                 break;
233         }
234         case MSG_STRUCT_SETTING_VOICE_MSG_OPT: {
235                 msg_struct->data = new MSG_VOICEMAIL_OPT_S;
236                 memset(msg_struct->data, 0x00, sizeof(MSG_VOICEMAIL_OPT_S));
237                 MSG_VOICEMAIL_OPT_S *pTmp = (MSG_VOICEMAIL_OPT_S *)msg_struct->data;
238                 pTmp->simIndex = MSG_SIM_SLOT_ID_1; /* default sim index */
239                 break;
240         }
241         case MSG_STRUCT_SETTING_GENERAL_OPT: {
242                 msg_struct->data = new MSG_GENERAL_OPT_S;
243                 memset(msg_struct->data, 0x00, sizeof(MSG_GENERAL_OPT_S));
244                 break;
245         }
246         case MSG_STRUCT_SETTING_MSGSIZE_OPT: {
247                 msg_struct->data = new MSG_MSGSIZE_OPT_S;
248                 memset(msg_struct->data, 0x00, sizeof(MSG_MSGSIZE_OPT_S));
249                 break;
250         }
251         case MSG_STRUCT_SMS_SENDOPT: {
252                 msg_struct->data = new SMS_SENDINGOPT_S;
253                 memset(msg_struct->data, 0x00, sizeof(SMS_SENDINGOPT_S));
254                 break;
255         }
256         case MSG_STRUCT_MMS_SENDOPT: {
257                 msg_struct->data = new MMS_SENDINGOPT_S;
258                 memset(msg_struct->data, 0x00, sizeof(MMS_SENDINGOPT_S));
259                 break;
260         }
261         case MSG_STRUCT_REQUEST_INFO: {
262                 MSG_REQUEST_S *pRequest = (MSG_REQUEST_S *)new MSG_REQUEST_S;
263                 memset(pRequest, 0x00, sizeof(MSG_REQUEST_S));
264                 msg_struct->data = pRequest;
265
266                 msg_struct_s *pMsg = (msg_struct_s *)new msg_struct_s;
267                 msg_struct_s *pOpt = (msg_struct_s *)new msg_struct_s;
268
269                 pRequest->msg = (msg_struct_t)pMsg;
270                 pRequest->sendOpt = (msg_struct_t)pOpt;
271
272                 pMsg->type = MSG_STRUCT_MESSAGE_INFO;
273                 msg_message_create_struct(pMsg);
274
275                 pOpt->type = MSG_STRUCT_SENDOPT;
276                 pOpt->data = new MSG_SENDINGOPT_S;
277                 memset(pOpt->data, 0x00, sizeof(MSG_SENDINGOPT_S));
278                 msg_struct_s *pSms = new msg_struct_s;
279                 msg_struct_s *pMms = new msg_struct_s;
280
281                 MSG_SENDINGOPT_S *sendOpt = (MSG_SENDINGOPT_S *)pOpt->data;
282
283                 sendOpt->mmsSendOpt = (msg_struct_t)pMms;
284                 sendOpt->smsSendOpt = (msg_struct_t)pSms;
285
286                 pMms->type = MSG_STRUCT_MMS_SENDOPT;
287                 pMms->data = new MMS_SENDINGOPT_S;
288                 memset(pMms->data, 0x00, sizeof(MMS_SENDINGOPT_S));
289
290                 pSms->type = MSG_STRUCT_SMS_SENDOPT;
291                 pSms->data = new SMS_SENDINGOPT_S;
292                 memset(pSms->data, 0x00, sizeof(SMS_SENDINGOPT_S));
293                 break;
294         }
295         case MSG_STRUCT_MMS:
296         case MSG_STRUCT_MMS_PAGE:
297         case MSG_STRUCT_MMS_MEDIA:
298         case MSG_STRUCT_MMS_ATTACH:
299         case MSG_STRUCT_MMS_REGION:
300         case MSG_STRUCT_MMS_TRANSITION:
301         case MSG_STRUCT_MMS_META:
302         case MSG_STRUCT_MMS_SMIL_TEXT:
303         case MSG_STRUCT_MMS_SMIL_AVI:
304         case MSG_STRUCT_MULTIPART_INFO:
305                 msg_struct->data = msg_mms_create_struct_data(field);
306                 break;
307         case MSG_STRUCT_PUSH_CONFIG_INFO:
308                 msg_struct->data = new MSG_PUSH_EVENT_INFO_S;
309                 memset(msg_struct->data, 0x00, sizeof(MSG_PUSH_EVENT_INFO_S));
310                 break;
311         default:
312                 delete msg_struct;
313                 return NULL;
314                 break;
315         }
316
317         return (msg_struct_t) msg_struct;
318 }
319
320
321 static int _release_msg_struct(msg_struct_t *msg_struct_handle)
322 {
323         msg_error_t err = MSG_SUCCESS;
324
325         if (msg_struct_handle == NULL || *msg_struct_handle == NULL)
326                 return MSG_ERR_NULL_POINTER;
327
328         msg_struct_s *msg_struct = (msg_struct_s *)*msg_struct_handle;
329
330         switch (msg_struct->type) {
331         case MSG_STRUCT_MESSAGE_INFO: {
332                 msg_message_release(&msg_struct);
333
334                 *msg_struct_handle = NULL;
335                 break;
336         }
337         case MSG_STRUCT_FILTER: {
338                 delete (MSG_FILTER_S*)(msg_struct->data);
339                 msg_struct->data = NULL;
340
341                 delete msg_struct;
342                 *msg_struct_handle = NULL;
343                 break;
344         }
345         case MSG_STRUCT_CONV_INFO: {
346                 MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S*)(msg_struct->data);
347
348                 if (pConv->multipart_list) {
349                         g_list_free_full((GList *)pConv->multipart_list, __msg_release_list_item);
350                         pConv->multipart_list = NULL;
351                 }
352
353                 if (pConv->pText) {
354                         delete [] pConv->pText;
355                         pConv->pText = NULL;
356                 }
357
358                 delete pConv;
359                 msg_struct->data = NULL;
360
361                 delete msg_struct;
362                 *msg_struct_handle = NULL;
363                 break;
364         }
365         case MSG_STRUCT_THREAD_INFO: {
366                 delete (MSG_THREAD_VIEW_S*)(msg_struct->data);
367                 msg_struct->data = NULL;
368
369                 delete msg_struct;
370                 *msg_struct_handle = NULL;
371                 break;
372         }
373         case MSG_STRUCT_SENDOPT: {
374                 MSG_SENDINGOPT_S *pOpt = (MSG_SENDINGOPT_S*)(msg_struct->data);
375                 delete (MMS_SENDINGOPT_S *)(((msg_struct_s *)pOpt->mmsSendOpt)->data);
376                 ((msg_struct_s *)pOpt->mmsSendOpt)->data = NULL;
377                 delete (msg_struct_s *)pOpt->mmsSendOpt;
378                 pOpt->mmsSendOpt = NULL;
379
380                 delete (SMS_SENDINGOPT_S *)(((msg_struct_s *)pOpt->smsSendOpt)->data);
381                 ((msg_struct_s *)pOpt->smsSendOpt)->data = NULL;
382                 delete (msg_struct_s *)pOpt->smsSendOpt;
383                 pOpt->smsSendOpt = NULL;
384
385                 delete pOpt;
386                 msg_struct->data = NULL;
387
388                 delete msg_struct;
389                 *msg_struct_handle = NULL;
390
391                 break;
392         }
393         case MSG_STRUCT_SYNCML_INFO: {
394                 MSG_SYNCML_MESSAGE_S *pSyncML = (MSG_SYNCML_MESSAGE_S*)(msg_struct->data);
395                 msg_struct_s *msg = (msg_struct_s *)pSyncML->msg;
396                 msg_message_release(&msg);
397
398                 delete pSyncML;
399                 msg_struct->data = NULL;
400
401                 delete msg_struct;
402                 *msg_struct_handle = NULL;
403                 break;
404         }
405         case MSG_STRUCT_COUNT_INFO: {
406                 delete (MSG_COUNT_INFO_S*)(msg_struct->data);
407                 msg_struct->data = NULL;
408
409                 delete msg_struct;
410                 *msg_struct_handle = NULL;
411                 break;
412         }
413         case MSG_STRUCT_THREAD_COUNT_INFO: {
414                 delete (MSG_THREAD_COUNT_INFO_S*)(msg_struct->data);
415                 msg_struct->data = NULL;
416
417                 delete msg_struct;
418                 *msg_struct_handle = NULL;
419
420                 break;
421         }
422         case MSG_STRUCT_THREAD_LIST_INDEX: {
423                 MSG_THREAD_LIST_INDEX_INFO_S *pThread = (MSG_THREAD_LIST_INDEX_INFO_S*)(msg_struct->data);
424                 delete (MSG_ADDRESS_INFO_S *)(((msg_struct_s *)pThread->msgAddrInfo)->data);
425                 ((msg_struct_s *)pThread->msgAddrInfo)->data = NULL;
426                 delete (msg_struct_s *)pThread->msgAddrInfo;
427                 pThread->msgAddrInfo = NULL;
428                 delete pThread;
429                 msg_struct->data = NULL;
430
431                 delete msg_struct;
432                 *msg_struct_handle = NULL;
433
434                 break;
435         }
436         case MSG_STRUCT_SORT_RULE: {
437                 delete (MSG_SORT_RULE_S*)(msg_struct->data);
438                 msg_struct->data = NULL;
439
440                 delete msg_struct;
441                 *msg_struct_handle = NULL;
442
443                 break;
444         }
445         case MSG_STRUCT_FOLDER_INFO: {
446                 delete (MSG_FOLDER_INFO_S*)(msg_struct->data);
447                 msg_struct->data = NULL;
448
449                 delete msg_struct;
450                 *msg_struct_handle = NULL;
451
452                 break;
453         }
454         case MSG_STRUCT_MSG_LIST_CONDITION: {
455                 MSG_LIST_CONDITION_S *pCond = (MSG_LIST_CONDITION_S*)(msg_struct->data);
456                 MSG_SORT_RULE_S *pSortRule = (MSG_SORT_RULE_S *)(((msg_struct_s *)pCond->sortRule)->data);
457
458                 delete (MSG_SORT_RULE_S *)pSortRule;
459                 ((msg_struct_s *)pCond->sortRule)->data = NULL;
460                 delete (msg_struct_s *)pCond->sortRule;
461                 pCond->sortRule = NULL;
462
463                 if (pCond->pAddressVal) {
464                         delete [] pCond->pAddressVal;
465                         pCond->pAddressVal = NULL;
466                 }
467
468                 if (pCond->pTextVal) {
469                         delete [] pCond->pTextVal;
470                         pCond->pTextVal = NULL;
471                 }
472
473                 delete (MSG_LIST_CONDITION_S*)(msg_struct->data);
474                 msg_struct->data = NULL;
475
476                 delete msg_struct;
477                 *msg_struct_handle = NULL;
478
479                 break;
480         }
481         case MSG_STRUCT_REPORT_STATUS_INFO: {
482                 delete (MSG_REPORT_STATUS_INFO_S*)(msg_struct->data);
483                 msg_struct->data = NULL;
484
485                 delete msg_struct;
486                 *msg_struct_handle = NULL;
487
488                 break;
489         }
490         case MSG_STRUCT_SMS_SENDOPT: {
491                 delete (SMS_SENDINGOPT_S*)(msg_struct->data);
492                 msg_struct->data = NULL;
493
494                 delete msg_struct;
495                 *msg_struct_handle = NULL;
496
497                 break;
498         }
499         case MSG_STRUCT_MMS_SENDOPT: {
500                 delete (MMS_SENDINGOPT_S*)(msg_struct->data);
501                 msg_struct->data = NULL;
502
503                 delete msg_struct;
504                 *msg_struct_handle = NULL;
505
506                 break;
507         }
508         case MSG_STRUCT_REQUEST_INFO: {
509                 MSG_REQUEST_S *pRequest = (MSG_REQUEST_S*)(msg_struct->data);
510
511                 MSG_SENDINGOPT_S *pSendingOpt = (MSG_SENDINGOPT_S *)(((msg_struct_s *)pRequest->sendOpt)->data);
512
513                 msg_struct_s *pMmsOpt = (msg_struct_s *)pSendingOpt->mmsSendOpt;
514                 msg_struct_s *pSmsOpt = (msg_struct_s *)pSendingOpt->smsSendOpt;
515
516                 delete (MMS_SENDINGOPT_S *)(pMmsOpt->data);
517                 pMmsOpt->data = NULL;
518                 delete (msg_struct_s *)pSendingOpt->mmsSendOpt;
519                 pSendingOpt->mmsSendOpt = NULL;
520                 delete (MMS_SENDINGOPT_S *)(pSmsOpt->data);
521                 pSmsOpt->data = NULL;
522                 delete (msg_struct_s *)pSendingOpt->smsSendOpt;
523                 pSendingOpt->smsSendOpt = NULL;
524
525                 delete (MSG_SENDINGOPT_S *)pSendingOpt;
526                 ((msg_struct_s *)pRequest->sendOpt)->data = NULL;
527                 delete (msg_struct_s *)pRequest->sendOpt;
528                 pRequest->sendOpt = NULL;
529
530                 msg_struct_s *msg = (msg_struct_s *)pRequest->msg;
531                 msg_message_release(&msg);
532
533                 delete pRequest;
534                 msg_struct->data = NULL;
535
536                 delete msg_struct;
537                 *msg_struct_handle = NULL;
538                 break;
539         }
540         case MSG_STRUCT_MMS:
541         case MSG_STRUCT_MMS_PAGE:
542         case MSG_STRUCT_MMS_MEDIA:
543         case MSG_STRUCT_MMS_ATTACH:
544         case MSG_STRUCT_MMS_REGION:
545         case MSG_STRUCT_MMS_TRANSITION:
546         case MSG_STRUCT_MMS_META:
547         case MSG_STRUCT_MMS_SMIL_TEXT:
548         case MSG_STRUCT_MMS_SMIL_AVI:
549         case MSG_STRUCT_MULTIPART_INFO: {
550                 msg_mms_release_struct(&msg_struct);
551                 *msg_struct_handle = NULL;
552                 break;
553         }
554         case MSG_STRUCT_SETTING_SMSC_OPT: {
555                 msg_struct_list_s *smsc_list = NULL;
556                 msg_struct_s *smsc_info = NULL;
557                 MSG_SMSC_LIST_HIDDEN_S *pTmp = NULL;
558
559                 pTmp = (MSG_SMSC_LIST_HIDDEN_S *)msg_struct->data;
560                 smsc_list = (msg_struct_list_s *)pTmp->smsc_list;
561
562                 for (int i = 0; i < SMSC_LIST_MAX; i++) {
563                         smsc_info = (msg_struct_s *)smsc_list->msg_struct_info[i];
564                         delete (MSG_SMSC_DATA_S*)(smsc_info->data);
565                         delete smsc_info;
566                 }
567
568                 g_free(smsc_list->msg_struct_info);
569
570                 delete smsc_list;
571
572                 delete pTmp;
573                 msg_struct->data = NULL;
574
575                 delete msg_struct;
576                 *msg_struct_handle = NULL;
577                 break;
578         }
579         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO: {
580                 delete (MSG_CB_CHANNEL_INFO_S*)(msg_struct->data);
581                 msg_struct->data = NULL;
582
583                 delete msg_struct;
584                 *msg_struct_handle = NULL;
585                 break;
586         }
587         case MSG_STRUCT_SETTING_CB_OPT: {
588                 msg_struct_list_s *cb_list = NULL;
589                 msg_struct_s *cb_info = NULL;
590                 MSG_CBMSG_OPT_HIDDEN_S *pTmp = NULL;
591
592                 pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)msg_struct->data;
593                 cb_list = (msg_struct_list_s *)pTmp->channelData;
594
595                 for (int i = 0; i < CB_CHANNEL_MAX; i++) {
596                         cb_info = (msg_struct_s *)cb_list->msg_struct_info[i];
597                         delete (MSG_CB_CHANNEL_INFO_S*)(cb_info->data);
598                         delete cb_info;
599                 }
600
601                 g_free(cb_list->msg_struct_info);
602
603                 delete cb_list;
604
605                 delete pTmp;
606                 msg_struct->data = NULL;
607
608                 delete msg_struct;
609                 *msg_struct_handle = NULL;
610                 break;
611         }
612         case MSG_STRUCT_SETTING_SMS_SEND_OPT: {
613                 delete (MSG_SMS_SENDOPT_S*)(msg_struct->data);
614                 msg_struct->data = NULL;
615
616                 delete msg_struct;
617                 *msg_struct_handle = NULL;
618                 break;
619         }
620         case MSG_STRUCT_SETTING_MMS_SEND_OPT: {
621                 delete (MSG_MMS_SENDOPT_S*)(msg_struct->data);
622                 msg_struct->data = NULL;
623
624                 delete msg_struct;
625                 *msg_struct_handle = NULL;
626                 break;
627         }
628         case MSG_STRUCT_SETTING_MMS_RECV_OPT: {
629                 delete (MSG_MMS_RECVOPT_S*)(msg_struct->data);
630                 msg_struct->data = NULL;
631
632                 delete msg_struct;
633                 *msg_struct_handle = NULL;
634                 break;
635         }
636         case MSG_STRUCT_SETTING_PUSH_MSG_OPT: {
637                 delete (MSG_PUSHMSG_OPT_S*)(msg_struct->data);
638                 msg_struct->data = NULL;
639
640                 delete msg_struct;
641                 *msg_struct_handle = NULL;
642                 break;
643         }
644         case MSG_STRUCT_SETTING_VOICE_MSG_OPT: {
645                 delete (MSG_VOICEMAIL_OPT_S*)(msg_struct->data);
646                 msg_struct->data = NULL;
647
648                 delete msg_struct;
649                 *msg_struct_handle = NULL;
650                 break;
651         }
652         case MSG_STRUCT_SETTING_GENERAL_OPT: {
653                 delete (MSG_GENERAL_OPT_S*)(msg_struct->data);
654                 msg_struct->data = NULL;
655
656                 delete msg_struct;
657                 *msg_struct_handle = NULL;
658                 break;
659         }
660         case MSG_STRUCT_SETTING_MSGSIZE_OPT: {
661                 delete (MSG_MSGSIZE_OPT_S*)(msg_struct->data);
662                 msg_struct->data = NULL;
663
664                 delete msg_struct;
665                 *msg_struct_handle = NULL;
666                 break;
667         }
668         case MSG_STRUCT_ADDRESS_INFO: {
669                 delete (MSG_ADDRESS_INFO_S*)(msg_struct->data);
670                 msg_struct->data = NULL;
671
672                 delete msg_struct;
673                 *msg_struct_handle = NULL;
674                 break;
675         }
676         case MSG_STRUCT_PUSH_CONFIG_INFO: {
677                 delete (MSG_PUSH_EVENT_INFO_S*)(msg_struct->data);
678                 msg_struct->data = NULL;
679
680                 delete msg_struct;
681                 *msg_struct_handle = NULL;
682                 break;
683         }
684         case MSG_STRUCT_MEDIA_INFO: {
685                 delete (MSG_MEDIA_INFO_S*)(msg_struct->data);
686                 msg_struct->data = NULL;
687
688                 delete msg_struct;
689                 *msg_struct_handle = NULL;
690                 break;
691         }
692         default:
693                 err = MSG_ERR_INVALID_PARAMETER;
694                 break;
695         }
696
697         return err;
698 }
699
700 EXPORT_API int msg_release_struct(msg_struct_t *msg_struct_handle)
701 {
702         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
703
704         int ret = _release_msg_struct(msg_struct_handle);
705
706         return ret;
707 }
708
709 EXPORT_API int msg_release_list_struct(msg_struct_list_s *msg_struct_list)
710 {
711         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
712         msg_error_t err = MSG_SUCCESS;
713
714         if (msg_struct_list == NULL)
715                 return MSG_ERR_NULL_POINTER;
716
717         if (msg_struct_list->msg_struct_info == NULL) {
718                 if (msg_struct_list->nCount > 0)
719                         msg_struct_list->nCount = 0;
720                 return MSG_ERR_NULL_POINTER;
721         }
722
723         if (msg_struct_list->nCount > 0) {
724                 int listCnt = msg_struct_list->nCount;
725
726                 for (int i = 0; i < listCnt; i++) {
727                         _release_msg_struct(&(msg_struct_list->msg_struct_info[i]));
728                 }
729         }
730
731         /* free peer info list */
732         g_free(msg_struct_list->msg_struct_info);
733         msg_struct_list->msg_struct_info = NULL;
734
735         msg_struct_list->nCount = 0;
736
737         return err;
738 }
739
740 EXPORT_API int msg_get_int_value(msg_struct_t msg_struct_handle, int field, int *value)
741 {
742         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
743         msg_error_t err = MSG_SUCCESS;
744
745         if (msg_struct_handle == NULL || value == NULL)
746                 return MSG_ERR_NULL_POINTER;
747
748         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
749         MSG_TYPE_CHECK(msg_struct->type, field);
750
751         if (msg_struct->data == NULL)
752                 return MSG_ERR_NULL_POINTER;
753
754         switch (msg_struct->type) {
755         case MSG_STRUCT_MESSAGE_INFO:
756                 err = msg_message_get_int_value(msg_struct->data, field, value);
757                 break;
758         case MSG_STRUCT_FILTER:
759                 err = msg_get_filter_info_int(msg_struct->data, field, value);
760                 break;
761         case MSG_STRUCT_SYNCML_INFO:
762                 err = msg_syncml_info_get_int(msg_struct->data, field, value);
763                 break;
764         case MSG_STRUCT_COUNT_INFO:
765                 err = msg_count_info_get_int(msg_struct->data, field, value);
766                 break;
767         case MSG_STRUCT_THREAD_COUNT_INFO:
768                 err = msg_thread_count_get_int(msg_struct->data, field, value);
769                 break;
770         case MSG_STRUCT_THREAD_LIST_INDEX:
771                 err = msg_thread_index_get_int(msg_struct->data, field, value);
772                 break;
773         case MSG_STRUCT_SORT_RULE:
774                 err = msg_sortrule_get_int(msg_struct->data, field, value);
775                 break;
776         case MSG_STRUCT_FOLDER_INFO:
777                 err = msg_folder_info_get_int(msg_struct->data, field, value);
778                 break;
779         case MSG_STRUCT_THREAD_INFO:
780                 err = msg_thread_info_get_int(msg_struct->data, field, value);
781                 break;
782         case MSG_STRUCT_CONV_INFO:
783                 err = msg_conv_info_get_int(msg_struct->data, field, value);
784                 break;
785         case MSG_STRUCT_MSG_LIST_CONDITION:
786                 err = msg_list_condition_get_int(msg_struct->data, field, value);
787                 break;
788         case MSG_STRUCT_REPORT_STATUS_INFO:
789                 err = msg_report_status_get_int(msg_struct->data, field, value);
790                 break;
791         case MSG_STRUCT_ADDRESS_INFO:
792                 err = msg_address_info_get_int(msg_struct->data, field, value);
793                 break;
794         case MSG_STRUCT_MMS_SENDOPT:
795                 err = msg_mms_sendopt_get_int(msg_struct->data, field, value);
796                 break;
797         case MSG_STRUCT_REJECT_MSG_INFO:
798                 err = msg_reject_message_get_int(msg_struct->data, field, value);
799                 break;
800         case MSG_STRUCT_REQUEST_INFO:
801                 err = msg_request_get_int(msg_struct->data, field, value);
802                 break;
803         case MSG_STRUCT_SENT_STATUS_INFO:
804                 err = msg_sent_status_get_int((MSG_SENT_STATUS_S *)msg_struct->data, field, value);
805                 break;
806         case MSG_STRUCT_CB_MSG:
807                 err = msg_cb_message_get_int_value(msg_struct->data, field, value);
808                 break;
809         case MSG_STRUCT_MMS:
810         case MSG_STRUCT_MMS_PAGE:
811         case MSG_STRUCT_MMS_MEDIA:
812         case MSG_STRUCT_MMS_ATTACH:
813         case MSG_STRUCT_MMS_REGION:
814         case MSG_STRUCT_MMS_TRANSITION:
815         case MSG_STRUCT_MMS_META:
816         case MSG_STRUCT_MMS_SMIL_TEXT:
817         case MSG_STRUCT_MMS_SMIL_AVI:
818         case MSG_STRUCT_MULTIPART_INFO:
819                 err = msg_mms_get_int_value(msg_struct, field, value);
820                 break;
821         case MSG_STRUCT_SETTING_SMSC_OPT:
822         case MSG_STRUCT_SETTING_SMSC_INFO:
823         case MSG_STRUCT_SETTING_CB_OPT:
824         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
825         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
826         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
827         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
828         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
829         case MSG_STRUCT_SETTING_GENERAL_OPT:
830         case MSG_STRUCT_SETTING_MSGSIZE_OPT:
831         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
832                 err = msg_setting_get_int_value(msg_struct, field, value);
833                 break;
834         case MSG_STRUCT_MEDIA_INFO:
835                 err = msg_media_item_get_int(msg_struct->data, field, value);
836                 break;
837         default:
838                 err = MSG_ERR_INVALID_PARAMETER;
839                 break;
840         }
841
842         return err;
843 }
844
845 EXPORT_API int msg_get_str_value(msg_struct_t msg_struct_handle, int field, char *value, int size)
846 {
847         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
848         msg_error_t err = MSG_SUCCESS;
849
850         if (msg_struct_handle == NULL || value == NULL)
851                 return MSG_ERR_NULL_POINTER;
852
853         if (size < 0)
854                 return MSG_ERR_INVALID_PARAMETER;
855
856         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
857
858         if (msg_struct->data == NULL)
859                 return MSG_ERR_NULL_POINTER;
860
861         switch (msg_struct->type) {
862         case MSG_STRUCT_MESSAGE_INFO:
863                 err = msg_message_get_str_value(msg_struct->data, field, value, size);
864                 break;
865         case MSG_STRUCT_FILTER:
866                 err = msg_get_filter_info_str(msg_struct->data, field, value, size);
867                 break;
868         case MSG_STRUCT_FOLDER_INFO:
869                 err = msg_folder_info_get_str(msg_struct->data, field, value, size);
870                 break;
871         case MSG_STRUCT_THREAD_INFO:
872                 err = msg_thread_info_get_str(msg_struct->data, field, value, size);
873                 break;
874         case MSG_STRUCT_CONV_INFO:
875                 err = msg_conv_info_get_str(msg_struct->data, field, value, size);
876                 break;
877         case MSG_STRUCT_MSG_LIST_CONDITION:
878                 err = msg_list_condition_get_str(msg_struct->data, field, value, size);
879                 break;
880
881         case MSG_STRUCT_ADDRESS_INFO:
882                 err = msg_address_info_get_str(msg_struct->data, field, value, size);
883                 break;
884
885         case MSG_STRUCT_REJECT_MSG_INFO:
886                 err = msg_reject_message_get_str(msg_struct->data, field, value, size);
887                 break;
888         case MSG_STRUCT_MEDIA_INFO:
889                 err = msg_media_item_get_str(msg_struct->data, field, value, size);
890                 break;
891         case MSG_STRUCT_MMS:
892         case MSG_STRUCT_MMS_PAGE:
893         case MSG_STRUCT_MMS_MEDIA:
894         case MSG_STRUCT_MMS_ATTACH:
895         case MSG_STRUCT_MMS_REGION:
896         case MSG_STRUCT_MMS_TRANSITION:
897         case MSG_STRUCT_MMS_META:
898         case MSG_STRUCT_MMS_SMIL_TEXT:
899         case MSG_STRUCT_MMS_SMIL_AVI:
900         case MSG_STRUCT_MULTIPART_INFO:
901                 err = msg_mms_get_str_value(msg_struct, field, value, size);
902                 break;
903         case MSG_STRUCT_SETTING_GENERAL_OPT:
904         case MSG_STRUCT_SETTING_SMSC_INFO:
905         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
906         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
907                 err = msg_setting_get_str_value(msg_struct, field, value, size);
908                 break;
909         case MSG_STRUCT_PUSH_CONFIG_INFO:
910                 err = msg_push_config_get_str(msg_struct->data, field, value, size);
911                 break;
912         case MSG_STRUCT_REPORT_STATUS_INFO:
913                 err = msg_report_status_get_str(msg_struct->data, field, value, size);
914                 break;
915         case MSG_STRUCT_CB_MSG:
916                 err = msg_cb_message_get_str_value(msg_struct->data, field, value, size);
917                 break;
918         default:
919                 err = MSG_ERR_INVALID_PARAMETER;
920                 break;
921         }
922
923         return err;
924 }
925
926 EXPORT_API int msg_get_bool_value(msg_struct_t msg_struct_handle, int field, bool *value)
927 {
928         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
929         msg_error_t err = MSG_SUCCESS;
930
931         if (msg_struct_handle == NULL || value == NULL)
932                 return MSG_ERR_NULL_POINTER;
933
934         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
935
936         if (msg_struct->data == NULL)
937                 return MSG_ERR_NULL_POINTER;
938
939         switch (msg_struct->type) {
940         case MSG_STRUCT_FILTER:
941                 err = msg_get_filter_info_bool(msg_struct->data, field, value);
942                 break;
943         case MSG_STRUCT_MESSAGE_INFO:
944                 err = msg_message_get_bool_value(msg_struct->data, field, value);
945                 break;
946         case MSG_STRUCT_THREAD_INFO:
947                 err = msg_thread_info_get_bool(msg_struct->data, field, value);
948                 break;
949         case MSG_STRUCT_CONV_INFO:
950                 err = msg_conv_get_bool(msg_struct->data, field, value);
951                 break;
952         case MSG_STRUCT_SENDOPT:
953                 err = msg_sendopt_get_bool(msg_struct->data, field, value);
954                 break;
955         case MSG_STRUCT_SORT_RULE:
956                 err = msg_sortrule_get_bool(msg_struct->data, field, value);
957                 break;
958         case MSG_STRUCT_MSG_LIST_CONDITION:
959                 err = msg_list_condition_get_bool(msg_struct->data, field, value);
960                 break;
961         case MSG_STRUCT_MMS_SENDOPT:
962                 err = msg_mms_sendopt_get_bool(msg_struct->data, field, value);
963                 break;
964         case MSG_STRUCT_SMS_SENDOPT:
965                 err = msg_sms_sendopt_get_bool(msg_struct->data, field, value);
966                 break;
967         case MSG_STRUCT_MMS:
968         case MSG_STRUCT_MMS_PAGE:
969         case MSG_STRUCT_MMS_MEDIA:
970         case MSG_STRUCT_MMS_ATTACH:
971         case MSG_STRUCT_MMS_REGION:
972         case MSG_STRUCT_MMS_TRANSITION:
973         case MSG_STRUCT_MMS_META:
974         case MSG_STRUCT_MMS_SMIL_TEXT:
975         case MSG_STRUCT_MMS_SMIL_AVI:
976                 err = msg_mms_get_bool_value(msg_struct, field, value);
977                 break;
978         case MSG_STRUCT_SETTING_CB_OPT:
979         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
980         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
981         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
982         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
983         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
984         case MSG_STRUCT_SETTING_GENERAL_OPT:
985                 err = msg_setting_get_bool_value(msg_struct, field, value);
986                 break;
987         case MSG_STRUCT_PUSH_CONFIG_INFO:
988                 err = msg_push_config_get_bool(msg_struct->data, field, value);
989                 break;
990         default:
991                 err = MSG_ERR_INVALID_PARAMETER;
992                 break;
993         }
994
995         return err;
996 }
997
998 EXPORT_API int msg_get_struct_handle(msg_struct_t msg_struct_handle, int field, msg_struct_t *value)
999 {
1000         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1001         msg_error_t err = MSG_SUCCESS;
1002
1003         if (msg_struct_handle == NULL || value == NULL)
1004                 return MSG_ERR_NULL_POINTER;
1005
1006         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1007
1008         if (msg_struct->data == NULL)
1009                 return MSG_ERR_NULL_POINTER;
1010
1011         switch (msg_struct->type) {
1012         case MSG_STRUCT_MESSAGE_INFO:
1013                 err = msg_message_get_struct_hnd(msg_struct->data, field, (void **)value);
1014                 break;
1015         case MSG_STRUCT_SENDOPT:
1016                 err = msg_sendopt_get_struct_handle(msg_struct, field, (void **)value);
1017                 break;
1018         case MSG_STRUCT_SYNCML_INFO:
1019                 err = msg_syncml_get_struct_handle(msg_struct, field, (void **)value);
1020                 break;
1021         case MSG_STRUCT_THREAD_LIST_INDEX:
1022                 err = msg_thread_index_get_struct_handle(msg_struct, field, (void **)value);
1023                 break;
1024         case MSG_STRUCT_MSG_LIST_CONDITION:
1025                 err = msg_list_condition_get_struct_handle(msg_struct, field, (void **)value);
1026                 break;
1027         case MSG_STRUCT_MMS_MEDIA:
1028                 err = msg_mms_get_struct_handle(msg_struct, field, (msg_struct_s**)value);
1029                 break;
1030         case MSG_STRUCT_REQUEST_INFO:
1031                 err = msg_request_get_struct_handle(msg_struct, field, (void **)value);
1032                 break;
1033         default:
1034                 err = MSG_ERR_INVALID_PARAMETER;
1035                 break;
1036         }
1037
1038         return err;
1039 }
1040
1041 EXPORT_API int msg_get_list_handle(msg_struct_t msg_struct_handle, int field, void **value)
1042 {
1043         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1044         msg_error_t err = MSG_SUCCESS;
1045
1046         if (msg_struct_handle == NULL || value == NULL)
1047                 return MSG_ERR_NULL_POINTER;
1048
1049         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1050
1051         if (msg_struct->data == NULL)
1052                 return MSG_ERR_NULL_POINTER;
1053
1054         switch (msg_struct->type) {
1055         case MSG_STRUCT_MESSAGE_INFO:
1056                 err = msg_message_get_list_hnd(msg_struct->data, field, value);
1057                 break;
1058         case MSG_STRUCT_CONV_INFO:
1059                 err = msg_conversation_get_list_hnd(msg_struct->data, field, value);
1060                 break;
1061         case MSG_STRUCT_MMS:
1062         case MSG_STRUCT_MMS_PAGE:
1063                 err = msg_mms_get_list_handle(msg_struct, field, (msg_list_handle_t *)value);
1064                 break;
1065         case MSG_STRUCT_SETTING_CB_OPT:
1066         case MSG_STRUCT_SETTING_SMSC_OPT:
1067                 err = msg_setting_get_list_handle(msg_struct, field, value);
1068                 break;
1069         default:
1070                 err = MSG_ERR_INVALID_PARAMETER;
1071                 break;
1072         }
1073
1074         return err;
1075 }
1076
1077 EXPORT_API int msg_set_int_value(msg_struct_t msg_struct_handle, int field, int value)
1078 {
1079         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1080         msg_error_t err = MSG_SUCCESS;
1081
1082         if (msg_struct_handle == NULL)
1083                 return MSG_ERR_NULL_POINTER;
1084
1085         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1086
1087         if (msg_struct->data == NULL)
1088                 return MSG_ERR_NULL_POINTER;
1089
1090         switch (msg_struct->type) {
1091         case MSG_STRUCT_MESSAGE_INFO:
1092                 err = msg_message_set_int_value(msg_struct->data, field, value);
1093                 break;
1094         case MSG_STRUCT_FILTER:
1095                 err = msg_set_filter_info_int(msg_struct->data, field, value);
1096                 break;
1097         case MSG_STRUCT_SYNCML_INFO:
1098                 err = msg_syncml_info_set_int(msg_struct->data, field, value);
1099                 break;
1100         case MSG_STRUCT_COUNT_INFO:
1101                 err = msg_count_info_set_int(msg_struct->data, field, value);
1102                 break;
1103         case MSG_STRUCT_THREAD_COUNT_INFO:
1104                 err = msg_thread_count_set_int(msg_struct->data, field, value);
1105                 break;
1106         case MSG_STRUCT_THREAD_LIST_INDEX:
1107                 err = msg_thread_index_set_int(msg_struct->data, field, value);
1108                 break;
1109         case MSG_STRUCT_SORT_RULE:
1110                 err = msg_sortrule_set_int(msg_struct->data, field, value);
1111                 break;
1112         case MSG_STRUCT_FOLDER_INFO:
1113                 err = msg_folder_info_set_int(msg_struct->data, field, value);
1114                 break;
1115         case MSG_STRUCT_MSG_LIST_CONDITION:
1116                 err = msg_list_condition_set_int(msg_struct->data, field, value);
1117                 break;
1118         case MSG_STRUCT_REPORT_STATUS_INFO:
1119                 err = msg_report_status_set_int(msg_struct->data, field, value);
1120                 break;
1121         case MSG_STRUCT_ADDRESS_INFO:
1122                 err = msg_address_info_set_int(msg_struct->data, field, value);
1123                 break;
1124         case MSG_STRUCT_MMS_SENDOPT:
1125                 err = msg_mms_sendopt_set_int(msg_struct->data, field, value);
1126                 break;
1127         case MSG_STRUCT_REJECT_MSG_INFO:
1128                 err = msg_reject_message_set_int(msg_struct->data, field, value);
1129                 break;
1130         case MSG_STRUCT_REQUEST_INFO:
1131                 err = msg_request_set_int(msg_struct->data, field, value);
1132                 break;
1133         case MSG_STRUCT_MMS:
1134         case MSG_STRUCT_MMS_PAGE:
1135         case MSG_STRUCT_MMS_MEDIA:
1136         case MSG_STRUCT_MMS_ATTACH:
1137         case MSG_STRUCT_MMS_REGION:
1138         case MSG_STRUCT_MMS_TRANSITION:
1139         case MSG_STRUCT_MMS_META:
1140         case MSG_STRUCT_MMS_SMIL_TEXT:
1141         case MSG_STRUCT_MMS_SMIL_AVI:
1142                 err = msg_mms_set_int_value(msg_struct, field, value);
1143                 break;
1144         case MSG_STRUCT_SETTING_SMSC_OPT:
1145         case MSG_STRUCT_SETTING_SMSC_INFO:
1146         case MSG_STRUCT_SETTING_CB_OPT:
1147         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
1148         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
1149         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
1150         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
1151         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
1152         case MSG_STRUCT_SETTING_GENERAL_OPT:
1153         case MSG_STRUCT_SETTING_MSGSIZE_OPT:
1154         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
1155                 err = msg_setting_set_int_value(msg_struct, field, value);
1156                 break;
1157         default:
1158                 err = MSG_ERR_INVALID_PARAMETER;
1159                 break;
1160         }
1161
1162         return err;
1163 }
1164
1165 EXPORT_API int msg_set_str_value(msg_struct_t msg_struct_handle, int field, const char *value, int size)
1166 {
1167         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1168         msg_error_t err = MSG_SUCCESS;
1169
1170         if (msg_struct_handle == NULL || value == NULL)
1171                 return MSG_ERR_NULL_POINTER;
1172
1173         if (size < 0)
1174                 return MSG_ERR_INVALID_PARAMETER;
1175
1176         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1177
1178         if (msg_struct->data == NULL)
1179                 return MSG_ERR_NULL_POINTER;
1180
1181         switch (msg_struct->type) {
1182         case MSG_STRUCT_MESSAGE_INFO:
1183                 err = msg_message_set_str_value(msg_struct->data, field, value, size);
1184                 break;
1185         case MSG_STRUCT_FILTER:
1186                 err = msg_set_filter_info_str(msg_struct->data, field, value, size);
1187                 break;
1188         case MSG_STRUCT_FOLDER_INFO:
1189                 err = msg_folder_info_set_str(msg_struct->data, field, value, size);
1190                 break;
1191         case MSG_STRUCT_MSG_LIST_CONDITION:
1192                 err = msg_list_condition_set_str(msg_struct->data, field, value, size);
1193                 break;
1194         case MSG_STRUCT_ADDRESS_INFO:
1195                 err = msg_address_info_set_str(msg_struct->data, field, value, size);
1196                 break;
1197         case MSG_STRUCT_REJECT_MSG_INFO:
1198                 err = msg_reject_message_set_str(msg_struct->data, field, value, size);
1199                 break;
1200         case MSG_STRUCT_MMS:
1201         case MSG_STRUCT_MMS_PAGE:
1202         case MSG_STRUCT_MMS_MEDIA:
1203         case MSG_STRUCT_MMS_ATTACH:
1204         case MSG_STRUCT_MMS_REGION:
1205         case MSG_STRUCT_MMS_TRANSITION:
1206         case MSG_STRUCT_MMS_META:
1207         case MSG_STRUCT_MMS_SMIL_TEXT:
1208         case MSG_STRUCT_MMS_SMIL_AVI:
1209         case MSG_STRUCT_MULTIPART_INFO:
1210                 err = msg_mms_set_str_value(msg_struct, field, value, size);
1211                 break;
1212         case MSG_STRUCT_SETTING_GENERAL_OPT:
1213         case MSG_STRUCT_SETTING_SMSC_INFO:
1214         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
1215         case MSG_STRUCT_SETTING_VOICE_MSG_OPT:
1216                 err = msg_setting_set_str_value(msg_struct, field, value, size);
1217                 break;
1218         case MSG_STRUCT_PUSH_CONFIG_INFO:
1219                 err = msg_push_config_set_str(msg_struct->data, field, value, size);
1220                 break;
1221         case MSG_STRUCT_MEDIA_INFO:
1222                 err = msg_media_info_set_str(msg_struct->data, field, value, size);
1223                 break;
1224         default:
1225                 err = MSG_ERR_INVALID_PARAMETER;
1226                 break;
1227         }
1228
1229         return err;
1230 }
1231
1232 EXPORT_API int msg_set_bool_value(msg_struct_t msg_struct_handle, int field, bool value)
1233 {
1234         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1235         msg_error_t err = MSG_SUCCESS;
1236
1237         if (msg_struct_handle == NULL)
1238                 return MSG_ERR_NULL_POINTER;
1239
1240         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1241
1242         if (msg_struct->data == NULL)
1243                 return MSG_ERR_NULL_POINTER;
1244
1245         switch (msg_struct->type) {
1246         case MSG_STRUCT_FILTER:
1247                 err = msg_set_filter_info_bool(msg_struct->data, field, value);
1248                 break;
1249         case MSG_STRUCT_MESSAGE_INFO:
1250                 err = msg_message_set_bool_value(msg_struct->data, field, value);
1251                 break;
1252         case MSG_STRUCT_SENDOPT:
1253                 err = msg_sendopt_set_bool(msg_struct->data, field, value);
1254                 break;
1255         case MSG_STRUCT_SORT_RULE:
1256                 err = msg_sortrule_set_bool(msg_struct->data, field, value);
1257                 break;
1258         case MSG_STRUCT_MSG_LIST_CONDITION:
1259                 err = msg_list_condition_set_bool(msg_struct->data, field, value);
1260                 break;
1261         case MSG_STRUCT_MMS_SENDOPT:
1262                 err = msg_mms_sendopt_set_bool(msg_struct->data, field, value);
1263                 break;
1264         case MSG_STRUCT_SMS_SENDOPT:
1265                 err = msg_sms_sendopt_set_bool(msg_struct->data, field, value);
1266                 break;
1267         case MSG_STRUCT_MMS:
1268         case MSG_STRUCT_MMS_PAGE:
1269         case MSG_STRUCT_MMS_MEDIA:
1270         case MSG_STRUCT_MMS_ATTACH:
1271         case MSG_STRUCT_MMS_REGION:
1272         case MSG_STRUCT_MMS_TRANSITION:
1273         case MSG_STRUCT_MMS_META:
1274         case MSG_STRUCT_MMS_SMIL_TEXT:
1275         case MSG_STRUCT_MMS_SMIL_AVI:
1276                 err = msg_mms_set_bool_value(msg_struct, field, value);
1277                 break;
1278         case MSG_STRUCT_SETTING_CB_OPT:
1279         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO:
1280         case MSG_STRUCT_SETTING_SMS_SEND_OPT:
1281         case MSG_STRUCT_SETTING_MMS_SEND_OPT:
1282         case MSG_STRUCT_SETTING_MMS_RECV_OPT:
1283         case MSG_STRUCT_SETTING_PUSH_MSG_OPT:
1284         case MSG_STRUCT_SETTING_GENERAL_OPT:
1285                 err = msg_setting_set_bool_value(msg_struct, field, value);
1286                 break;
1287         case MSG_STRUCT_PUSH_CONFIG_INFO:
1288                 err = msg_push_config_set_bool(msg_struct->data, field, value);
1289                 break;
1290         default:
1291                 err = MSG_ERR_INVALID_PARAMETER;
1292                 break;
1293         }
1294
1295         return err;
1296 }
1297
1298 EXPORT_API int msg_set_struct_handle(msg_struct_t msg_struct_handle, int field, msg_struct_t value)
1299 {
1300         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1301         msg_error_t err = MSG_SUCCESS;
1302
1303         if (msg_struct_handle == NULL || value == NULL)
1304                 return MSG_ERR_NULL_POINTER;
1305
1306         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1307
1308         if (msg_struct->data == NULL)
1309                 return MSG_ERR_NULL_POINTER;
1310
1311         switch (msg_struct->type) {
1312         case MSG_STRUCT_MESSAGE_INFO:
1313                 err = msg_message_set_struct_hnd(msg_struct->data, field, (void *)value);
1314                 break;
1315         case MSG_STRUCT_SENDOPT:
1316                 err = msg_sendopt_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1317                 break;
1318         case MSG_STRUCT_SYNCML_INFO:
1319                 err = msg_syncml_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1320                 break;
1321         case MSG_STRUCT_THREAD_LIST_INDEX:
1322                 err = msg_thread_index_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1323                 break;
1324         case MSG_STRUCT_MSG_LIST_CONDITION:
1325                 err = msg_list_condition_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1326                 break;
1327         case MSG_STRUCT_MMS_MEDIA:
1328                 err = msg_mms_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1329                 break;
1330         case MSG_STRUCT_REQUEST_INFO:
1331                 err = msg_request_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1332                 break;
1333         default:
1334                 err = MSG_ERR_INVALID_PARAMETER;
1335                 break;
1336         }
1337
1338         return err;
1339 }
1340
1341 EXPORT_API int msg_set_list_handle(msg_struct_t msg_struct_handle, int field, void *value)
1342 {
1343         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1344         msg_error_t err = MSG_SUCCESS;
1345
1346         if (msg_struct_handle == NULL || value == NULL)
1347                 return MSG_ERR_NULL_POINTER;
1348
1349         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1350
1351         if (msg_struct->data == NULL)
1352                 return MSG_ERR_NULL_POINTER;
1353
1354 #if 0 /* No operations */
1355         switch (msg_struct->type) {
1356         default:
1357                 err = MSG_ERR_INVALID_PARAMETER;
1358                 break;
1359         }
1360 #endif
1361
1362         return err;
1363 }
1364
1365 EXPORT_API int msg_list_add_item(msg_struct_t msg_struct_handle, int field, msg_struct_t *item)
1366 {
1367         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1368         if (msg_struct_handle == NULL || item == NULL)
1369                 return MSG_ERR_NULL_POINTER;
1370
1371         msg_error_t err = MSG_SUCCESS;
1372         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1373
1374         switch (msg_struct->type) {
1375         case MSG_STRUCT_MESSAGE_INFO: {
1376                 err = msg_message_list_append(msg_struct_handle, field, item);
1377         }
1378         break;
1379         case MSG_STRUCT_MMS:
1380         case MSG_STRUCT_MMS_PAGE: {
1381                 err = msg_mms_list_append(msg_struct_handle, field, item);
1382         }
1383         break;
1384         default:
1385                 err = MSG_ERR_INVALID_PARAMETER;
1386                 break;
1387         }
1388
1389         return err;
1390 }
1391
1392 EXPORT_API msg_struct_t msg_list_nth_data(msg_list_handle_t list_handle, int index)
1393 {
1394         CHECK_MSG_SUPPORTED_RETURN_NULL(MSG_TELEPHONY_SMS_FEATURE);
1395         if (list_handle == NULL)
1396                 return NULL;
1397
1398         return (msg_struct_t)g_list_nth_data((GList *)list_handle, (guint)index);
1399 }
1400
1401 EXPORT_API int msg_list_length(msg_list_handle_t list_handle)
1402 {
1403         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1404         if (list_handle == NULL) {
1405                 return 0;
1406         }
1407
1408         return (int)g_list_length((GList *)list_handle);
1409 }
1410
1411 EXPORT_API int msg_list_clear(msg_struct_t msg_struct_handle, int field)
1412 {
1413         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1414         if (msg_struct_handle == NULL)
1415                 return MSG_ERR_NULL_POINTER;
1416
1417         msg_error_t err = MSG_SUCCESS;
1418         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1419
1420         switch (msg_struct->type) {
1421         case MSG_STRUCT_MESSAGE_INFO: {
1422                 err = msg_message_list_clear(msg_struct_handle, field);
1423         }
1424         break;
1425         default:
1426                 err = MSG_ERR_INVALID_PARAMETER;
1427                 break;
1428         }
1429
1430         return err;
1431 }
1432
1433 EXPORT_API int msg_list_free(msg_list_handle_t list_handle)
1434 {
1435         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1436         if (list_handle == NULL)
1437                 return MSG_ERR_NULL_POINTER;
1438
1439         g_list_free_full((GList *)list_handle, __msg_release_list_item);
1440         list_handle = NULL;
1441
1442         return MSG_SUCCESS;
1443 }
1444
1445
1446 EXPORT_API int msg_util_calculate_text_length(const char* msg_text, msg_encode_type_t msg_encode_type_to, unsigned int *text_size, unsigned int *segment_size, msg_encode_type_t *msg_encode_type_in)
1447 {
1448         CHECK_MSG_SUPPORTED(MSG_TELEPHONY_SMS_FEATURE);
1449         msg_error_t err = MSG_SUCCESS;
1450
1451         if (msg_text == NULL || text_size == NULL || segment_size == NULL || msg_encode_type_in == NULL)
1452                 return MSG_ERR_INVALID_PARAMETER;
1453
1454         if (msg_encode_type_to > MSG_ENCODE_ASCII7BIT) {
1455                 MSG_FATAL("unsupported msg_encode_type [%d]", msg_encode_type_to);
1456                 return MSG_ERR_INVALID_PARAMETER;
1457         }
1458
1459         msg_encode_type_t encodeType = MSG_ENCODE_AUTO;
1460         MSG_LANGUAGE_ID_T langId = MSG_LANG_ID_RESERVED;
1461
1462         int decodeLen = 0;
1463         int bufSize = 0;
1464         int textSize = 0;
1465
1466         bool bAbnormal = false;
1467
1468         textSize = strlen(msg_text);
1469
1470         bufSize = textSize * 4;
1471
1472         unsigned char decodeData[bufSize+1];
1473         memset(decodeData, 0x00, sizeof(decodeData));
1474
1475         MsgTextConvert *textCvt = MsgTextConvert::instance();
1476
1477         *text_size = 0;
1478         *segment_size = 0;
1479
1480         switch (msg_encode_type_to) {
1481         case MSG_ENCODE_GSM7BIT:
1482                 decodeLen = textCvt->convertUTF8ToGSM7bit(decodeData, bufSize, (const unsigned char*)msg_text, textSize, &langId, &bAbnormal);
1483                 break;
1484         case MSG_ENCODE_UCS2:
1485                 decodeLen = textCvt->convertUTF8ToUCS2(decodeData, bufSize, (const unsigned char*)msg_text, textSize);
1486                 break;
1487         case MSG_ENCODE_AUTO: {
1488                 msg_encode_type_t defaultEncodingType = MSG_ENCODE_GSM7BIT;
1489                 bool CDMASupported = MsgCheckFeatureSupport(MSG_TELEPHONY_CDMA_FEATURE);
1490                 if (CDMASupported) {
1491                         defaultEncodingType = MSG_ENCODE_ASCII7BIT;
1492                 }
1493                 decodeLen = textCvt->convertUTF8ToAuto(decodeData, bufSize, (const unsigned char*)msg_text, textSize, defaultEncodingType, &encodeType);
1494         }
1495         break;
1496         default:
1497                 return MSG_ERR_INVALID_PARAMETER;
1498         }
1499
1500         /* calculate segment size. */
1501         int headerLen = 0;
1502         int concat = 5;
1503         int lang = 3;
1504
1505         int headerSize = 0;
1506         int segSize = 0;
1507
1508         if (langId != MSG_LANG_ID_RESERVED) {
1509                 MSG_DEBUG("National Language Exists");
1510                 headerSize += lang;
1511                 headerLen = 1;
1512         }
1513
1514         if (msg_encode_type_to == MSG_ENCODE_GSM7BIT || encodeType == MSG_ENCODE_GSM7BIT) {
1515                 MSG_DEBUG("MSG_ENCODE_GSM7BIT");
1516
1517                 if ((decodeLen + headerSize) > 160) {
1518                         headerLen = 1;
1519                         segSize = ((140 - (headerLen + concat + headerSize)) * 8)/7;
1520                 } else {
1521                         segSize = ((140 - headerLen - headerSize) * 8) / 7;
1522                 }
1523
1524                 if (bAbnormal)
1525                         *msg_encode_type_in = MSG_ENCODE_GSM7BIT_ABNORMAL;
1526                 else
1527                         *msg_encode_type_in = MSG_ENCODE_GSM7BIT;
1528
1529         } else if (msg_encode_type_to == MSG_ENCODE_UCS2 || encodeType == MSG_ENCODE_UCS2) {
1530                 MSG_DEBUG("MSG_ENCODE_UCS2");
1531
1532                 if (decodeLen > 140) {
1533                         headerLen = 1;
1534                         segSize = 140 - (headerLen + concat);
1535                 } else {
1536                         segSize = 140;
1537                 }
1538
1539                 *msg_encode_type_in = MSG_ENCODE_UCS2;
1540         } else if (encodeType == MSG_ENCODE_ASCII7BIT) {
1541                 MSG_DEBUG("MSG_ENCODE_ASCII7BIT");
1542
1543                 if(decodeLen > 160)
1544                         segSize = ((140*8) - ((headerLen + concat)*8)) / 7;
1545                 else
1546                         segSize = 160;
1547
1548                 *msg_encode_type_in = MSG_ENCODE_GSM7BIT;
1549         } else {
1550                 MSG_DEBUG("Unsupported encode type.");
1551                 err = MSG_ERR_INVALID_PARAMETER;
1552                 return err;
1553         }
1554
1555         MSG_DEBUG("decodeLen [%d] segSize [%d]", decodeLen, segSize);
1556
1557         *text_size = decodeLen;
1558         *segment_size = segSize;
1559
1560         return err;
1561 }