path: root/src/plugins/ds-public/vcard/src/plugin_interface.c

/*
 * oma-ds-agent
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *
 * 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 <stdio.h>
#include <contacts.h>
#include <glib.h>

#include <sync_agent.h>

#include "plugin_spec.h"
#include "in_datastore_info_vcard.h"
#include "encoding_util.h"

#ifndef EXPORT_API
#define EXPORT_API __attribute__ ((visibility("default")))
#endif

#ifndef OMADS_AGENT_LOG
#undef LOG_TAG
#define LOG_TAG "PLUGIN_VCARD"
#endif

static int _free_obj_field_info(sync_agent_plugin_field_info_s * field_list, int count);
static int _set_obj_field_info(sync_agent_plugin_field_info_s ** field_list, int count, vcard_field_list_s * input_list);
static char *_convert_key_name(int key);

static int _get_content(const char *value, void *data);

static sync_agent_da_return_e _convert_service_error_to_common_error(contacts_error_e err);
static char *_contacts_vcard_put_content(const char *vcard_stream, const char *content_type, const char *content_value);
static int _contacts_vcard_get_content(const char *vcard_stream, const char *content_type, int (*fn) (const char *content_value, void *data), void *data);

static void _contacts_struct_merge(contacts_record_h old, contacts_record_h new);
static void __contacts_struct_property_merge(contacts_record_h old, contacts_record_h new);
static void __contacts_struct_child_property_merge(unsigned int property_id, contacts_record_h old, contacts_record_h new);

//static void _remove_vcard_field(CTSstruct *contact);
//static void _remove_vcard_gslist_field(gpointer data, gpointer user_data);

EXPORT_API sync_agent_da_return_e sync_agent_plugin_converter(const void *agent_data, void **service_data)
{
	_EXTERN_FUNC_ENTER;

//      retvm_if(agent_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] agent_data is NULL");
//
//      sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
//      int err = 0;
//      CTSstruct *temp_service_data = 0;
//
//      /* decoding & convert */
//      _DEBUG_INFO("[dc_vcard_plugIn] agent data : %s\n", agent_data);
//      char *de_agent_data;
//      int src_len = strlen(agent_data);
//      int de_agent_data_len = 0;
//
//      if (check_encoding_data(agent_data) == 1) {
//              err = proc_decoding(agent_data, src_len, &de_agent_data, &de_agent_data_len);
//              if (err == 0) {
//                      _DEBUG_ERROR("[dc_vcard_plugIn] proc_decoding() Fail!\n");
//                      ret = SYNC_AGENT_DA_ERRORS;
//                      return ret;
//              }
//
//              err = contacts_svc_get_contact_from_vcard((const void *)de_agent_data, &temp_service_data);
//
//              /*memory free */
//              if (de_agent_data != NULL)
//                      free(de_agent_data);
//      } else {
//              err = contacts_svc_get_contact_from_vcard(agent_data, &temp_service_data);
//      }
//
//      if (err < CTS_SUCCESS) {
//              _DEBUG_ERROR("[dc_vcard_plugIn] contacts_svc_get_contact_from_vcard() Fail!\n");
//              ret = _convert_service_error_to_common_error(err);
//              *service_data = 0;
//      } else {
//              _DEBUG_INFO("[dc_vcard_plugIn] contacts_svc_get_contact_from_vcard() Success!\n");
//              *service_data = (void *)temp_service_data;
//      }

	retvm_if(agent_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] agent_data is NULL");

	sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
	contacts_error_e err = CONTACTS_ERROR_NONE;
	contacts_list_h list = NULL;
	contacts_record_h record = NULL;
	contacts_record_h cloned_record = NULL;

	/* decoding & convert */
	_DEBUG_INFO("[dc_vcard_plugIn] agent data : %s\n", agent_data);
	char *de_agent_data;
	int src_len = strlen(agent_data);
	int de_agent_data_len = 0;

	if (check_encoding_data(agent_data) == 1) {
		err = proc_decoding(agent_data, src_len, &de_agent_data, &de_agent_data_len);
		if (err == 0) {
			_DEBUG_ERROR("[dc_vcard_plugIn] proc_decoding() Fail!\n");
			ret = SYNC_AGENT_DA_ERRORS;
			return ret;
		}

		err = contacts_vcard_parse_to_contacts(de_agent_data, &list);

		/*memory free */
		if (de_agent_data != NULL)
			free(de_agent_data);
	} else {
		err = contacts_vcard_parse_to_contacts(agent_data, &list);
	}

	if (err != CONTACTS_ERROR_NONE) {
		_DEBUG_ERROR("[dc_vcard_plugIn] contacts_vcard_parse_to_contacts() Fail!\n");
		ret = _convert_service_error_to_common_error(err);
		*service_data = 0;
	} else {
		_DEBUG_INFO("[dc_vcard_plugIn] contacts_vcard_parse_to_contacts() Success!\n");
		err = contacts_list_get_current_record_p(list, &record);
		if (err != CONTACTS_ERROR_NONE) {
			_DEBUG_ERROR("[dc_vcard_plugIn] contacts_list_get_current_record_p() Fail!\n");
			ret = _convert_service_error_to_common_error(err);
			*service_data = 0;
			contacts_list_destroy(list, true);
			return ret;
		}

		err = contacts_record_clone(record, &cloned_record);
		if (err != CONTACTS_ERROR_NONE) {
			_DEBUG_ERROR("[dc_vcard_plugIn] contacts_record_clone() Fail!\n");
			ret = _convert_service_error_to_common_error(err);
			*service_data = 0;
			contacts_list_destroy(list, true);
			return ret;
		}

		*service_data = (void *)cloned_record;
		contacts_list_destroy(list, true);
	}

	_EXTERN_FUNC_EXIT;
	return ret;
}

EXPORT_API sync_agent_da_return_e sync_agent_plugin_replace_converter(void *old_service_data, const void *agent_data, void **new_service_data)
{
	_EXTERN_FUNC_ENTER;

//      retvm_if(old_service_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] old_service_data is NULL");
//      retvm_if(agent_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] agent_data is NULL");
//
//      sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
//      int err = 0;
//      CTSstruct *temp_new_service_data = 0;
//      CTSstruct *temp_old_service_data = (CTSstruct *)old_service_data;
//
//      /* 1. agent_data  encoding check
//       *  2. decoding
//       *  3. copy to new_service_data
//       */
//      /* decoding */
//      char *de_agent_data;
//      int src_len = strlen(agent_data);
//      int de_agent_data_len = 0;
//
//      if (check_encoding_data(agent_data) == 1) {
//              err = proc_decoding(agent_data, src_len, &de_agent_data, &de_agent_data_len);
//              if (err == 0) {
//                      _DEBUG_ERROR("[dc_vcard_plugIn] proc_decoding() Fail!\n");
///*                    ret = SYNC_AGENT_DA_ERRORS;
//                      return ret;*/
//                      err = contacts_svc_get_contact_from_vcard(agent_data, &temp_new_service_data);
//              } else {
//                      _DEBUG_INFO("[dc_vcard_plugIn] proc_decoding() Success l!\n");
//                      err = contacts_svc_get_contact_from_vcard((const void *)de_agent_data, &temp_new_service_data);
//
//                      /*memory free */
//                      if (de_agent_data != NULL)
//                              free(de_agent_data);
//              }
//      } else {
//              err = contacts_svc_get_contact_from_vcard(agent_data, &temp_new_service_data);
//      }
//
//      if (err < CTS_SUCCESS) {
//              _DEBUG_ERROR("[dc_vcard_plugIn] contacts_svc_get_contact_from_vcard() Fail!\n");
//              ret = _convert_service_error_to_common_error(err);
//              *new_service_data = 0;
//
//              /*  memory free */
//              if (temp_old_service_data != NULL)
//                      contacts_svc_struct_free(temp_old_service_data);
//
//      } else {
//              _DEBUG_INFO("[dc_vcard_plugIn] contacts_svc_get_contact_from_vcard() Success!\n");
//              _remove_vcard_field(temp_old_service_data);
//              err = contacts_svc_struct_merge(temp_old_service_data, temp_new_service_data);
//              if (err < CTS_SUCCESS) {
//                      _DEBUG_ERROR("[dc_vcard_plugIn] contacts_svc_struct_merge() Fail!\n");
//                      ret = _convert_service_error_to_common_error(err);
//                      *new_service_data = 0;
//
//                      /*  memory free */
//                      if (temp_old_service_data != NULL)
//                              contacts_svc_struct_free(temp_old_service_data);
//              } else {
//                      _DEBUG_INFO("[dc_vcard_plugIn] contacts_svc_struct_merge() Success!\n");
//                      *new_service_data = (void *)temp_old_service_data;
//              }
//      }
//
//      /* memory free */
//      if (temp_new_service_data != NULL)
//              contacts_svc_struct_free(temp_new_service_data);

	retvm_if(old_service_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] old_service_data is NULL");
	retvm_if(agent_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] agent_data is NULL");

	sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;

	contacts_error_e err = CONTACTS_ERROR_NONE;
	contacts_list_h list = NULL;

	contacts_record_h temp_new_service_data = NULL;
	contacts_record_h temp_old_service_data = (contacts_record_h) old_service_data;

	/* 1. agent_data  encoding check
	 *  2. decoding
	 *  3. copy to new_service_data
	 */
	/* decoding */
	char *de_agent_data;
	int src_len = strlen(agent_data);
	int de_agent_data_len = 0;

	if (check_encoding_data(agent_data) == 1) {
		err = proc_decoding(agent_data, src_len, &de_agent_data, &de_agent_data_len);
		if (err == 0) {
			_DEBUG_ERROR("[dc_vcard_plugIn] proc_decoding() Fail!\n");
/*			ret = SYNC_AGENT_DA_ERRORS;
			return ret;*/
			err = contacts_vcard_parse_to_contacts(agent_data, &list);
		} else {
			_DEBUG_INFO("[dc_vcard_plugIn] proc_decoding() Success l!\n");
			err = contacts_vcard_parse_to_contacts(de_agent_data, &list);

			/*memory free */
			if (de_agent_data != NULL)
				free(de_agent_data);
		}
	} else {
		err = contacts_vcard_parse_to_contacts(agent_data, &list);
	}

	if (err != CONTACTS_ERROR_NONE) {
		_DEBUG_ERROR("[dc_vcard_plugIn] contacts_vcard_parse_to_contacts() Fail!\n");
		ret = _convert_service_error_to_common_error(err);
		*new_service_data = 0;

	} else {
		_DEBUG_INFO("[dc_vcard_plugIn] contacts_vcard_parse_to_contacts() Success!\n");

		err = contacts_list_get_current_record_p(list, &temp_new_service_data);
		if (err != CONTACTS_ERROR_NONE) {
			_DEBUG_ERROR("[dc_vcard_plugIn] contacts_list_get_current_record_p() Fail!\n");
			ret = _convert_service_error_to_common_error(err);
			*new_service_data = 0;
			goto DACI_FINISH;
		}

		_contacts_struct_merge(temp_old_service_data, temp_new_service_data);

		*new_service_data = (void *)temp_old_service_data;
	}

 DACI_FINISH:

	contacts_list_destroy(list, true);

	_EXTERN_FUNC_EXIT;
	return ret;
}

EXPORT_API sync_agent_da_return_e sync_agent_plugin_reverse_converter(void *service_data, void **agent_data)
{
	_EXTERN_FUNC_ENTER;

//      retvm_if(service_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] service_data is NULL");
//
//      sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
//      int err = 0;
//      char *temp_agent_data = 0;
//      CTSstruct *temp_service_data = (CTSstruct *)service_data;
//
//      /* Reverse_Converter */
//      err = contacts_svc_get_vcard_from_contact(temp_service_data, &temp_agent_data);
//      if (err < CTS_SUCCESS) {
//              _DEBUG_INFO("[dc_vcard_plugIn] contacts_svc_get_vcard_from_contact() Fail!\n");
//              ret = _convert_service_error_to_common_error(err);
//              *agent_data = 0;
//      } else {
//              _DEBUG_INFO("[dc_vcard_plugIn] contacts_svc_get_vcard_from_contact() Success!\n");
//              *agent_data = (void *)temp_agent_data;
//      }
//
//      /*  memory free */
//      if (temp_service_data != NULL)
//              contacts_svc_struct_free(temp_service_data);

	retvm_if(service_data == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] service_data is NULL");

	sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
	contacts_error_e err = CONTACTS_ERROR_NONE;

	char *temp_agent_data = 0;
	contacts_record_h record = (contacts_record_h) service_data;

	char *display_name = NULL;
	int id;
	contacts_record_get_str_p(record, _contacts_contact.display_name, &display_name);
	contacts_record_get_int(record, _contacts_contact.id, &id);

	_DEBUG_INFO("display_name = %s", display_name);
	_DEBUG_INFO("id = %d", id);

	/* Reverse_Converter */
	err = contacts_vcard_make_from_contact(record, &temp_agent_data);
	if (err != CONTACTS_ERROR_NONE) {
		_DEBUG_ERROR("[dc_vcard_plugIn] contacts_vcard_make_from_contact() Fail!\n");
		ret = _convert_service_error_to_common_error(err);
		*agent_data = 0;
	} else {
		_DEBUG_INFO("[dc_vcard_plugIn] contacts_vcard_make_from_contact() Success!\n");
		*agent_data = (void *)temp_agent_data;
		_DEBUG_INFO("temp_agent_data = %s", temp_agent_data);
	}

	contacts_record_destroy(record, true);

	_EXTERN_FUNC_EXIT;
	return ret;
}

EXPORT_API void *sync_agent_plugin_alloc_object()
{
	_EXTERN_FUNC_ENTER;

	char *agent_data = "BEGIN:VCARD\r\n\
VERSION:2.1\r\n\
END:VCARD";

	_EXTERN_FUNC_EXIT;
	return (void *)agent_data;
}

EXPORT_API int sync_agent_plugin_free_object(void *in_object)
{
	_EXTERN_FUNC_ENTER;
	_DEBUG_INFO("[dc_vcard_plugIn] Do nothing\n");

	return 1;
}

EXPORT_API void *sync_agent_plugin_set_value(void *in_object, int key, char *extension_key, void *value)
{
	_EXTERN_FUNC_ENTER;

	char *new_agent_data = 0;
	char *key_name = 0;

	if (key == VCARD_CONTENT_NO_TYPE)
		return (void *)new_agent_data;
	else if (key == VCARD_CONTENT_EXTENSION)
		key_name = extension_key;
	else
		key_name = _convert_key_name(key);

	new_agent_data = _contacts_vcard_put_content((const char *)in_object, (const char *)key_name, (const char *)value);

	_EXTERN_FUNC_EXIT;
	return (void *)new_agent_data;
}

EXPORT_API void *sync_agent_plugin_get_value(void *in_object, int key, char *extension_key)
{
	_EXTERN_FUNC_ENTER;

	char data[5000] = { 0, };	/* hard coding : size 1000 */
	char *key_name = 0;
	int result;

	if (key == VCARD_CONTENT_NO_TYPE)
		return 0;
	else if (key == VCARD_CONTENT_EXTENSION)
		key_name = extension_key;
	else
		key_name = _convert_key_name(key);

	result = _contacts_vcard_get_content((const char *)in_object, (const char *)key_name, _get_content, data);
	if (result == 0) {
		_EXTERN_FUNC_EXIT;
		return 0;
	}

	_EXTERN_FUNC_EXIT;

	if (strlen(data) == 0)
		return 0;
	else
		return strdup(data);
}

EXPORT_API sync_agent_plugin_object_info_s *sync_agent_plugin_get_obj_info()
{
	_EXTERN_FUNC_ENTER;

	sync_agent_plugin_object_info_s *obj_info = (sync_agent_plugin_object_info_s *) calloc(1, sizeof(sync_agent_plugin_object_info_s));
	if (obj_info == NULL) {
		_DEBUG_ERROR("CALLOC failed !!!");
		return NULL;
	}

	obj_info->type = VCARD_TYPE;
	obj_info->version = VCARD_VERSION;
	obj_info->field_cnt = sizeof(vcard_field_list) / sizeof(vcard_field_list_s);

	if (obj_info->field_cnt > 0)
		if (_set_obj_field_info(&(obj_info->field_list), obj_info->field_cnt, vcard_field_list) == 0) {
			/* for prevent */
			if (obj_info != NULL)
				free(obj_info);

			return NULL;
		}

	_EXTERN_FUNC_EXIT;
	return obj_info;
}

EXPORT_API int sync_agent_plugin_free_obj_info(sync_agent_plugin_object_info_s * obj_info)
{
	_EXTERN_FUNC_ENTER;

	if (obj_info != NULL) {
		if (obj_info->field_cnt > 0)
			if (_free_obj_field_info(obj_info->field_list, obj_info->field_cnt) == 0)
				return 0;

		free(obj_info);
	}

	_EXTERN_FUNC_EXIT;
	return 1;
}

static int _free_obj_field_info(sync_agent_plugin_field_info_s * field_list, int count)
{
	_INNER_FUNC_ENTER;

	int field_count = 0;
	sync_agent_plugin_field_info_s *child = NULL;

	if (field_list != NULL) {
		for (field_count = 0; field_count < count; field_count++) {
			child = field_list + field_count;
			if (child->field_child_cnt > 0)
				if (_free_obj_field_info(child->field_child_list, child->field_child_cnt) == 0)
					return 0;
		}
		free(field_list);
	}

	_INNER_FUNC_EXIT;
	return 1;
}

static int _set_obj_field_info(sync_agent_plugin_field_info_s ** field_list, int count, vcard_field_list_s * input_list)
{
	_INNER_FUNC_ENTER;

	int field_count = 0;
	sync_agent_plugin_field_info_s *child = NULL;

	*field_list = (sync_agent_plugin_field_info_s *) calloc(count, sizeof(sync_agent_plugin_field_info_s));
	if (*field_list == NULL) {
		_DEBUG_ERROR("CALLOC failed !!!");
		return 0;
	}

	for (field_count = 0; field_count < count; field_count++) {
		child = (*field_list) + field_count;
		child->field_name = input_list[field_count].field_name;
		_DEBUG_TRACE("[%s]", child->field_name);

		if (input_list[field_count].field_enum == VCARD_FIELD_BEGIN || input_list[field_count].field_enum == VCARD_FIELD_END) {
			child->field_child_cnt = sizeof(vcard_field_list_begin_end) / sizeof(vcard_field_list_s);
			_DEBUG_TRACE("----------");
			_set_obj_field_info(&(child->field_child_list), child->field_child_cnt, vcard_field_list_begin_end);
			_DEBUG_TRACE("==========");
		} else if (input_list[field_count].field_enum == VCARD_FIELD_VERSION) {
			child->field_child_cnt = sizeof(vcard_field_list_version) / sizeof(vcard_field_list_s);
			_DEBUG_TRACE("----------");
			_set_obj_field_info(&(child->field_child_list), child->field_child_cnt, vcard_field_list_version);
			_DEBUG_TRACE("==========");
		} else if (input_list[field_count].field_enum == VCARD_FIELD_ADR) {
			child->field_child_cnt = sizeof(vcard_field_list_adr) / sizeof(vcard_field_list_s);
			_DEBUG_TRACE("----------");
			_set_obj_field_info(&(child->field_child_list), child->field_child_cnt, vcard_field_list_adr);
			_DEBUG_TRACE("==========");
		} else if (input_list[field_count].field_enum == VCARD_FIELD_TEL) {
			child->field_child_cnt = sizeof(vcard_field_list_tel) / sizeof(vcard_field_list_s);
			_DEBUG_TRACE("----------");
			_set_obj_field_info(&(child->field_child_list), child->field_child_cnt, vcard_field_list_tel);
			_DEBUG_TRACE("==========");
		} else if (input_list[field_count].field_enum == VCARD_FIELD_EMAIL) {
			child->field_child_cnt = sizeof(vcard_field_list_email) / sizeof(vcard_field_list_s);
			_DEBUG_TRACE("----------");
			_set_obj_field_info(&(child->field_child_list), child->field_child_cnt, vcard_field_list_email);
			_DEBUG_TRACE("==========");
		}
	}

	_INNER_FUNC_EXIT;
	return 1;
}

static char *_convert_key_name(int key)
{
	_INNER_FUNC_ENTER;

	char *key_name = 0;

	switch (key) {
	case VCARD_CONTENT_FN:
		key_name = "FN";
		break;
	case VCARD_CONTENT_N:
		key_name = "N";
		break;
	case VCARD_CONTENT_NICKNAME:
		key_name = "NICKNAME";
		break;
	case VCARD_CONTENT_PHOTO:
		key_name = "PHOTO";
		break;
	case VCARD_CONTENT_BDAY:
		key_name = "BDAY";
		break;
	case VCARD_CONTENT_ADR:
		key_name = "ADR";
		break;
	case VCARD_CONTENT_LABEL:
		key_name = "LABEL";
		break;
	case VCARD_CONTENT_TEL:
		key_name = "TEL";
		break;
	case VCARD_CONTENT_EMAIL:
		key_name = "EMAIL";
		break;
	case VCARD_CONTENT_TITLE:
		key_name = "TITLE";
		break;
	case VCARD_CONTENT_ROLE:
		key_name = "ROLE";
		break;
	case VCARD_CONTENT_ORG:
		key_name = "ORG";
		break;
	case VCARD_CONTENT_NOTE:
		key_name = "NOTE";
		break;
	case VCARD_CONTENT_REV:
		key_name = "REV";
		break;
	case VCARD_CONTENT_UID:
		key_name = "UID";
		break;
	case VCARD_CONTENT_URL:
		key_name = "URL";
		break;
	case VCARD_CONTENT_X_ANNIVERSARY:
		key_name = "X-ANNIVERSARY";
		break;
	case VCARD_CONTENT_X_IRMC_LUID:
		key_name = "X-IRMC-LUID";
		break;
	default:
		break;
	}

	_INNER_FUNC_EXIT;
	return key_name;
}

static int _get_content(const char *value, void *data)
{
	_INNER_FUNC_ENTER;

	retvm_if(value == NULL, SYNC_AGENT_DA_ERRORS, "[dc_vcard_plugIn] value is NULL");

	const char *line_breaker = "\r";
	char *colon_loc = 0;
	char *line_breaker_loc = 0;
	int data_size = 0;

	colon_loc = (char *)value;
	line_breaker_loc = strstr(colon_loc, line_breaker);
	data_size = line_breaker_loc - colon_loc;
	_DEBUG_TRACE("[dc_vcard_plugIn] value : %s", value);
	_DEBUG_TRACE("[dc_vcard_plugIn] colon_loc : %s", colon_loc);
	_DEBUG_TRACE("[dc_vcard_plugIn] line_breaker_loc : %s", line_breaker_loc);
	_DEBUG_TRACE("[dc_vcard_plugIn] data_size : %d", data_size);

	/* hard coding : size 5000 */
	memcpy((char *)data, colon_loc, data_size);

	_INNER_FUNC_EXIT;
	return 1;
}

static sync_agent_da_return_e _convert_service_error_to_common_error(contacts_error_e err)
{
	_INNER_FUNC_ENTER;

	sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
	_DEBUG_TRACE("[da_contact_plugIn] Error Code : %d\n", err);

	switch (err) {
	case CONTACTS_ERROR_NONE:
		ret = SYNC_AGENT_DA_SUCCESS;
		break;
	case CONTACTS_ERROR_OUT_OF_MEMORY:
		ret = SYNC_AGENT_DA_ERR_MEMORY_FULL;
		break;
	case CONTACTS_ERROR_INVALID_PARAMETER:
		ret = SYNC_AGENT_DA_ERR_INVALID_PARAMETER;
		break;
	case CONTACTS_ERROR_NO_DATA:
		ret = SYNC_AGENT_DA_ERR_NO_DATA;
		break;
	case CONTACTS_ERROR_DB:
		ret = SYNC_AGENT_DA_ERR_SERVICE_DB;
		break;
	case CONTACTS_ERROR_IPC:
		ret = SYNC_AGENT_DA_ERR_SERVICE_IPC;
		break;
	default:
		ret = SYNC_AGENT_DA_ERRORS;
		break;
	}

	_INNER_FUNC_EXIT;

	return ret;
}

static char *_contacts_vcard_put_content(const char *vcard_stream, const char *content_type, const char *content_value)
{
	_INNER_FUNC_ENTER;

	int i, org_len, new_len;
	char *new_stream, *cur;
	const char *end_content = "END:VCARD";

	retvm_if(NULL == vcard_stream, NULL, "vcard_stream is NULL");
	retvm_if(NULL == content_type, NULL, "content_type is NULL");
	retvm_if(NULL == content_value, NULL, "content_value is NULL");

	org_len = strlen(vcard_stream);
	new_len = org_len + strlen(content_type) + strlen(content_value) + 8;

	new_stream = malloc(new_len);
	retvm_if(NULL == new_stream, NULL, "malloc() Failed");

	memcpy(new_stream, vcard_stream, org_len);

	i = 1;
	for (cur = new_stream + new_len - 1; cur; cur--) {
		if (end_content[9 - i] == *cur) {
			if (9 == i)
				break;
			i++;
			continue;
		} else {
			i = 1;
		}
	}
	if (9 != i) {
		_DEBUG_ERROR("vcard_stream is invalid(%s)", vcard_stream);
		free(new_stream);
		_INNER_FUNC_EXIT;
		return NULL;
	}

	cur += snprintf(cur, new_len - (cur - new_stream), "%s:", content_type);
	cur = strncpy(cur, content_value, new_len - (cur - new_stream));
	snprintf(cur, new_len - (cur - new_stream), "\r\n%s\r\n", end_content);

	_INNER_FUNC_EXIT;

	return new_stream;
}

static int _contacts_vcard_get_content(const char *vcard_stream, const char *content_type, int (*fn) (const char *content_value, void *data), void *data)
{
	_INNER_FUNC_ENTER;

	int len, buf_size, type_len;
	char *cursor, *found, *value;

	retv_if(NULL == vcard_stream, 0);
	retv_if(NULL == content_type, 0);
	retv_if(NULL == fn, 0);

	type_len = strlen(content_type);
	value = malloc(1024);
	retvm_if(NULL == value, 0, "malloc() Failed");
	buf_size = 1024;

	while ((found = strstr(vcard_stream, content_type))) {
		if ((found != vcard_stream && '\n' != *(found - 1))
		    && ':' != *(found + type_len + 1))
			continue;

		cursor = found;
		while (*cursor) {
			if ('\r' == *cursor)
				cursor++;
			if ('\n' == *cursor) {
				if (' ' != *(cursor + 1))
					break;
			}

			cursor++;
		}
		len = cursor - found;
		if (len < buf_size) {
			if(value)
				memcpy(value, found, len);
		} else {
			value = realloc(value, len + 1);
			if (value) {
				buf_size = len + 1;
				memcpy(value, found, len);
			} else {
				vcard_stream = found + type_len;
				continue;
			}
		}

		if (value)
			value[len] = '\0';

		if (fn) {
			if (fn(value + type_len + 1, data)) {
				free(value);
				_INNER_FUNC_EXIT;
				return 0;
			}
		}
		vcard_stream = found + type_len;
	}

	free(value);

	_INNER_FUNC_EXIT;
	return 1;
}

static void _contacts_struct_merge(contacts_record_h old, contacts_record_h new)
{
	_INNER_FUNC_ENTER;

	__contacts_struct_property_merge(old, new);

	__contacts_struct_child_property_merge(_contacts_contact.name, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.image, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.company, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.note, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.number, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.email, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.event, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.messenger, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.address, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.url, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.nickname, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.profile, old, new);
//      __contacts_struct_child_property_merge(_contacts_contact.relationship, old, new);
//      __contacts_struct_child_property_merge(_contacts_contact.group_relation, old, new);
	__contacts_struct_child_property_merge(_contacts_contact.extension, old, new);

	_INNER_FUNC_EXIT;
}

static void __contacts_struct_property_merge(contacts_record_h old, contacts_record_h new)
{
	_INNER_FUNC_ENTER;

//      contacts_error_e err = CONTACTS_ERROR_NONE;
//
//      char *ringtone_path = NULL;
//      char *image_thumbnail_path = NULL;
//      char *uid = NULL;
//      char *vibration = NULL;
//
//      err = contacts_record_get_str_p(new, _contacts_contact.ringtone_path, &ringtone_path);
//      if (err != CONTACTS_ERROR_NONE)
//              _DEBUG_ERROR("contacts_record_get_str_p(ringtone_path) is failed");
//
//      if (ringtone_path != NULL) {
//              _DEBUG_TRACE("ringtone_path = %s", ringtone_path);
//              err = contacts_record_set_str(old, _contacts_contact.ringtone_path, ringtone_path);
//              if (err != CONTACTS_ERROR_NONE)
//                      _DEBUG_ERROR("contacts_record_set_str(%s) is failed", ringtone_path);
//      }
//
//      err = contacts_record_get_str_p(new, _contacts_contact.image_thumbnail_path, &image_thumbnail_path);
//      if (err != CONTACTS_ERROR_NONE)
//              _DEBUG_ERROR("contacts_record_get_str_p(image_thumbnail_path) is failed");
//
//      if (image_thumbnail_path != NULL) {
//              _DEBUG_TRACE("image_thumbnail_path = %s", image_thumbnail_path);
//              err = contacts_record_set_str(old, _contacts_contact.image_thumbnail_path, image_thumbnail_path);
//              if (err != CONTACTS_ERROR_NONE)
//                      _DEBUG_ERROR("contacts_record_set_str(%s) is failed", image_thumbnail_path);
//      }
//
//      err = contacts_record_get_str_p(new, _contacts_contact.uid, &uid);
//      if (err != CONTACTS_ERROR_NONE)
//              _DEBUG_ERROR("contacts_record_get_str_p(uid) is failed");
//
//      if (uid != NULL) {
//              _DEBUG_TRACE("uid = %s", uid);
//              err = contacts_record_set_str(old, _contacts_contact.uid, uid);
//              if (err != CONTACTS_ERROR_NONE)
//                      _DEBUG_ERROR("contacts_record_set_str(%s) is failed", uid);
//      }
//
//      err = contacts_record_get_str_p(new, _contacts_contact.vibration, &vibration);
//      if (err != CONTACTS_ERROR_NONE)
//              _DEBUG_ERROR("contacts_record_get_str_p(vibration) is failed");
//
//      if (vibration != NULL) {
//              _DEBUG_TRACE("vibration = %s", vibration);
//              err = contacts_record_set_str(old, _contacts_contact.vibration, vibration);
//              if (err != CONTACTS_ERROR_NONE)
//                      _DEBUG_ERROR("contacts_record_set_str(%s) is failed", vibration);
//      }

	contacts_error_e err = CONTACTS_ERROR_NONE;

	char *image_thumbnail_path = NULL;

	err = contacts_record_get_str_p(new, _contacts_contact.image_thumbnail_path, &image_thumbnail_path);
	if (err != CONTACTS_ERROR_NONE)
		_DEBUG_ERROR("contacts_record_get_str_p(image_thumbnail_path) is failed");

	if (image_thumbnail_path != NULL) {
		_DEBUG_TRACE("image_thumbnail_path = %s", image_thumbnail_path);
		err = contacts_record_set_str(old, _contacts_contact.image_thumbnail_path, image_thumbnail_path);
		if (err != CONTACTS_ERROR_NONE)
			_DEBUG_ERROR("contacts_record_set_str(%s) is failed", image_thumbnail_path);
	}

	_INNER_FUNC_EXIT;
}

static void __contacts_struct_child_property_merge(unsigned int property_id, contacts_record_h old, contacts_record_h new)
{
	_INNER_FUNC_ENTER;

	contacts_error_e err = CONTACTS_ERROR_NONE;

	unsigned int old_count = 0;
	unsigned int new_count = 0;

	contacts_record_h old_record = NULL;
	contacts_record_h new_record = NULL;
	contacts_record_h new_cloned_record = NULL;

	_DEBUG_TRACE("property_id = %d", property_id);

	err = contacts_record_get_child_record_count(old, property_id, &old_count);
	if (err != CONTACTS_ERROR_NONE)
		_DEBUG_ERROR("contacts_record_get_child_record_count is failed");

	_DEBUG_TRACE("old_count = %d", old_count);

	int i;
	for (i = 0; i < old_count; i++) {

		err = contacts_record_get_child_record_at_p(old, property_id, 0, &old_record);
		if (err != CONTACTS_ERROR_NONE)
			_DEBUG_ERROR("contacts_record_get_child_record_at_p is failed");

		err = contacts_record_remove_child_record(old, property_id, old_record);
		if (err != CONTACTS_ERROR_NONE)
			_DEBUG_ERROR("contacts_record_remove_child_record is failed");
	}

	err = contacts_record_get_child_record_count(new, property_id, &new_count);
	if (err != CONTACTS_ERROR_NONE)
		_DEBUG_ERROR("contacts_record_get_child_record_count is failed");

	_DEBUG_TRACE("new_count = %d", new_count);

	for (i = 0; i < new_count; i++) {

		err = contacts_record_get_child_record_at_p(new, property_id, i, &new_record);
		if (err != CONTACTS_ERROR_NONE)
			_DEBUG_ERROR("contacts_record_get_child_record_at_p is failed");

		err = contacts_record_clone(new_record, &new_cloned_record);
		if (err != CONTACTS_ERROR_NONE)
			_DEBUG_ERROR("contacts_record_clone is failed");

		err = contacts_record_add_child_record(old, property_id, new_cloned_record);
		if (err != CONTACTS_ERROR_NONE)
			_DEBUG_ERROR("contacts_record_add_child_record is failed");
	}

	_INNER_FUNC_EXIT;
}

//static void _remove_vcard_field(CTSstruct *contact)
//{
//      _INNER_FUNC_ENTER;
//
//      GSList *numbers = 0, *email = 0, *event = 0, *postal = 0, *web = 0, *nick = 0;
//      CTSvalue *name = 0, *company = 0, *base = 0;
//
//      /* free name */
//      contacts_svc_struct_get_value(contact, CTS_CF_NAME_VALUE, &name);
//      contacts_svc_value_set_str(name, CTS_NAME_VAL_FIRST_STR, 0);
//      contacts_svc_value_set_str(name, CTS_NAME_VAL_LAST_STR, 0);
//      contacts_svc_value_set_str(name, CTS_NAME_VAL_ADDITION_STR, 0);
//      contacts_svc_value_set_str(name, CTS_NAME_VAL_SUFFIX_STR, 0);
//      contacts_svc_value_set_str(name, CTS_NAME_VAL_PREFIX_STR, 0);
//      contacts_svc_value_set_str(name, CTS_NAME_VAL_FIRST_STR, 0);
//
//      /* free company */
//      contacts_svc_struct_get_value(contact, CTS_VALUE_COMPANY, &company);
//      contacts_svc_value_set_str(company, CTS_COMPANY_VAL_NAME_STR, 0);
//      contacts_svc_value_set_str(company, CTS_COMPANY_VAL_DEPARTMENT_STR, 0);
//      contacts_svc_value_set_str(company, CTS_COMPANY_VAL_JOB_TITLE_STR, 0);
//      contacts_svc_value_set_str(company, CTS_COMPANY_VAL_ROLE_STR, 0);
//
//      /* free base */
//      contacts_svc_struct_get_value(contact, CTS_CF_BASE_INFO_VALUE, &base);
//      contacts_svc_value_set_str(base, CTS_BASE_VAL_IMG_PATH_STR, 0);
//      //contacts_svc_value_set_str(base, CTS_BASE_VAL_FULL_IMG_PATH_STR, 0);
//      contacts_svc_value_set_str(base, CTS_NOTE_VAL_NOTE_STR, 0);
//
//      /* free number */
//      contacts_svc_struct_get_list(contact, CTS_CF_NUMBER_LIST, &numbers);
//      g_slist_foreach(numbers, _remove_vcard_gslist_field, (gpointer) CTS_NUM_VAL_DELETE_BOOL);
//
//      /* free email */
//      contacts_svc_struct_get_list(contact, CTS_CF_EMAIL_LIST, &email);
//      g_slist_foreach(email, _remove_vcard_gslist_field, (gpointer) CTS_EMAIL_VAL_DELETE_BOOL);
//
//      /* free event */
//      contacts_svc_struct_get_list(contact, CTS_CF_EVENT_LIST, &event);
//      g_slist_foreach(event, _remove_vcard_gslist_field, (gpointer) CTS_EVENT_VAL_DELETE_BOOL);
//
//      /* free postal */
//      contacts_svc_struct_get_list(contact, CTS_CF_POSTAL_ADDR_LIST, &postal);
//      g_slist_foreach(postal, _remove_vcard_gslist_field, (gpointer) CTS_POSTAL_VAL_DEFAULT_BOOL);
//
//      /* free web */
//      contacts_svc_struct_get_list(contact, CTS_CF_WEB_ADDR_LIST, &web);
//      g_slist_foreach(web, _remove_vcard_gslist_field, (gpointer) CTS_WEB_VAL_DELETE_BOOL);
//
//      /* free nick */
//      contacts_svc_struct_get_list(contact, CTS_CF_NICKNAME_LIST, &nick);
//      g_slist_foreach(nick, _remove_vcard_gslist_field, (gpointer) CTS_NICKNAME_VAL_DELETE_BOOL);
//
//      _INNER_FUNC_EXIT;
//}
//
//static void _remove_vcard_gslist_field(gpointer data, gpointer user_data)
//{
//      _INNER_FUNC_ENTER;
//
//      contacts_svc_value_set_bool((CTSvalue *) data, (int)user_data, 1);
//
//      _INNER_FUNC_EXIT;
//}