2 * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 #define MAX_TYPE_NAME_LEN 50
22 #define MAX_PARAM_NAME_LEN 50
26 #define VFREE(obj) if (obj != NULL) { /*VDATA_TRACE("%p",obj);*/ free(obj); \
30 #define TRIM(obj) if (obj != NULL) {\
35 #define UPPER(obj, start, end) if (obj != NULL) {\
36 for (start = 0; start < end; start++)\
37 obj[start] = toupper(obj[start]);\
40 #define GO_NEXT_CHAR(current, rowData, addedCnt) {\
46 #define SET_PARAM_VALUE(PARAM, SZVALUE, LIST, LISTCNT, PARAMOBJ, PTYPE, ENC) {\
48 PARAM |= __VCardGetValue(SZVALUE, LIST, LISTCNT);\
49 if (PARAM != UNKNOWN_NAME) {\
50 PARAMOBJ->parameter = PTYPE;\
51 if (PTYPE == VCARD_PARAM_ENCODING)\
57 #define LENGTH_TYPE_LIST(obj, len) for (len = 0; obj[len] != NULL; len++);
59 extern char* _VUnfoldingNoSpecNew(char *string);
61 /** GLOBAL VARIABLE DECLARATION AND INITIALIZATION */
63 char* pszCardTypeList[] = {
64 "ADR", /* Delivery Address -> address*/
65 "AGENT", /* Agent -> assistant name, assistant number*/
66 "BDAY", /* Birthday -> birthday */
67 "BEGIN", /* BEGIN VCARD DELIMITER*/
68 "CATEGORIES", /* Categories is a multivalued attribute */
70 "EMAIL", /* Email -> email */
71 "END", /* END VCARD DELIMITER*/
72 "FN", /* Formatted Name -> display_name */
73 "GEO", /* Geographic Positioning*/
74 "KEY", /* Public Key*/
75 "LABEL", /* Label Address -> address*/
77 "MAILER", /* Email Program (Optional)*/
78 "N", /* Name -> name */
79 "NAME", /* Name -> name */
80 "NICKNAME", /* Nickname -> nickname */
81 "NOTE", /* Note -> note */
82 "ORG", /* Organization Name or Organizational unit -> department*/
83 "PHOTO", /* Photograph -> caller id*/
86 "REV", /* Last Revision(combination of calendar date & time)*/
87 "ROLE", /* Role or occupation */
91 "TEL", /* Telephone -> phone number */
92 "TITLE", /* Job Title -> job title */
94 "UID", /* Unique Identifier*/
95 "URL", /* URL -> web address */
96 "VERSION", /* Version*/
102 char* pszCardParamList[] = {
111 /** Encoding value */
112 ValueObj pEncList[] = {
114 {"BASE64", 0x00000002},
115 {"QUOTED-PRINTABLE", 0x00000004},
116 {"7BIT", 0x00000008},
120 /** Character set value */
121 ValueObj pCharsetList[] = {
122 {"UTF-8", 0x00000001},
123 {"UTF-16", 0x00000002},
124 {"ISO-8859-1", 0x00000004}
128 ValueObj pValueList[] = {
129 {"BINARY", 0x00000001},
130 {"BOOLEAN", 0x00000002},
131 {"DATE", 0x00000004},
132 {"DATE-TIME", 0x00000008},
133 {"FLOAT", 0x00000010},
134 {"INTEGER", 0x00000020},
135 {"PHONE-NUMBER", 0x00000040},
136 {"TEXT", 0x00000080},
137 {"TIME", 0x00000100},
140 {"UTC-OFFSET", 0x00000800},
141 {"VCARD", 0x00001000}
145 ValueObj pTypeList[] = {
146 {"AIFF", 0x00000001},
149 {"CELL", 0x00000008},
151 {"WORK", 0x00000020},
154 {"HOME", 0x00000100},
155 {"INTL", 0x00000200},
156 {"INTERNET", 0x00000400},
157 {"ISDN", 0x00000800},
158 {"JPEG", 0x00001000},
159 {"MOBILE", 0x00002000},
160 {"MODEM", 0x00004000},
162 {"PAGER", 0x00010000},
163 {"PARCEL", 0x00020000},
167 {"POSTAL", 0x00200000},
168 {"PREF", 0x00400000},
169 {"VIDEO", 0x00800000},
170 {"VOICE", 0x01000000},
171 {"WAVE", 0x02000000},
172 {"WBMP", 0x04000000},
177 /** FUNCTION DECLARATION */
178 int __VCardGetName(char*, char**, int);
179 int __VCardGetValue(char*, const ValueObj*, int);
180 int __VCardGetTypeName(char*, int*, int*);
181 int __VCardGetParamName(char*, int*, int*);
182 int __VIsVcardFile(char*, int);
183 char* __VCardGetParamVal(char*, int*, int*);
184 char* __VCardGetTypeVal(char*, int*, int*, int, VObject*);
185 char* __VCardTypeEncode(VObject*, char*);
186 char* __VCardParamEncode(VObject*, int*);
188 #ifdef VDATA_GROUPNAME_SUPPORTED
190 #endif /* VDATA_GROUPNAME_SUPPORTED */
194 * __VCardGetName() compares the string and vCard type, parameter name.
196 * @param szString Name which will compare
197 * @param pszList[] Name list of vCard type and param
198 * @param size Number of total element of list
200 * @return index The index in the list
203 __VCardGetName(char* szString, char* pszList[], int size)
206 int high, low, i, diff;
211 for (; high >= low; diff < 0 ? (low = i+1) : (high = i-1)) {
212 i = (low + high) / 2;
213 if ((diff = strcmp(pszList[i], szString)) == 0) /* success: found it */
221 * __VCardGetValue() compares the string and vCard type, parameter value.
223 * @param szString Value which will compare
224 * @param list[] Value list of vCard param
225 * @param size Number of total element of list
227 * @return flag The value's flag.
230 __VCardGetValue(char* szString, const ValueObj list[], int size)
233 int i = 0, diff = -1;
234 char* szTemp = szString;
236 SysRequireEx(szString, UNKNOWN_NAME);
237 SysRequireEx(size > 0, UNKNOWN_NAME);
239 UPPER(szTemp, i, strlen(szTemp));
241 for (i = 0; i < size-1; i++) {
242 VDATA_TRACE(" i : %d", i);
243 VDATA_TRACE(" for loop %d < %d, list[%d] : %d, list[%d].szName : %p", i, size, i, list[i].flag, i, list[i].szName);
244 VDATA_TRACE(" i : %d", i);
245 if (list[i].szName != NULL) {
246 VDATA_TRACE(" list[%d].szName != NULL", i);
247 VDATA_TRACE(" before strcmp %s %s", list[i].szName, szTemp);
248 VDATA_TRACE(" before strcmp %d", strcmp(list[i].szName, szTemp));
249 if ((diff = strcmp(list[i].szName, szTemp)) == 0) { /* success: found it */
250 VDATA_TRACE(" return %d", list[i].flag);
254 VDATA_TRACE(" after strcmp %s %s", list[i].szName, szTemp);
257 VDATA_TRACE(" return UNKNOWN_NAME");
263 * __VCardGetTypeName() fine the type name and returns the index number
265 * @param pVCardRaw The raw data
266 * @param pStatus Decoder status
267 * @param pDLen retrived length
269 * @return res The index in type list
272 __VCardGetTypeName(char* pVCardRaw, int* pStatus, int* pDLen)
277 char name[MAX_TYPE_NAME_LEN+1] = {0,};
279 #ifdef VDATA_GROUPNAME_SUPPORTED
280 char* szGroupName = NULL;
281 #endif /* VDATA_GROUPNAME_SUPPORTED */
283 SysRequireEx(pVCardRaw, UNKNOWN_NAME);
290 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
293 * TYPE NAME's length is must be less than MAX_TYPE_NAME_LEN.
294 * If TYPE NAME's value is over MAX_TYPE_NAME_LEN, return UNKNOWN_NAME.
295 * And then Decoding Step shoud not be changed.
297 if (index >= MAX_TYPE_NAME_LEN) {
298 *pStatus = VCARD_TYPE_NAME_STATUS;
304 * There is a delimeter between TYPE NAME and next element(=Param, or Type Value).
305 * If VTYPE_TOKEN_SEMICOLON or VTYPE_TOKEN_COLON is faced with,
306 * find TYPE NAME's value in pszCardTypeList, and then return searched result.
308 if ((c == VTYPE_TOKEN_SEMICOLON) || (c == VTYPE_TOKEN_COLON)) {
311 UPPER(name, i, index);
312 res = __VCardGetName(name, (char**)pszCardTypeList, VCARD_TYPE_NUM);
315 /** current version not support grouping vcard type */
316 else if (c == VTYPE_TOKEN_DOT) {
317 #ifdef VDATA_GROUPNAME_SUPPORTED
319 szGroupName = (char*) calloc(1, index+1);
320 if (szGroupName != NULL) {
321 strncpy(szGroupName, name, index);
322 gszGroupName = szGroupName;
328 * There is no new line in TYPE NAME.
329 * If new line character is faced with, return UNKNOWN_NAME;
331 else if ((c == '\r') || (c == '\n')) {
333 *pStatus = VCARD_TYPE_NAME_STATUS;
336 } else if (_VIsSpace(c)) {
345 if (c == VTYPE_TOKEN_SEMICOLON)
347 * This case next token is parameter. So set VCARD_PARAM_NAME_STATUS step.
349 *pStatus = VCARD_PARAM_NAME_STATUS;
351 if (res != UNKNOWN_NAME)
353 * This case next string is value. So set VCARD_TYPE_VALUE_STATUS step.
355 *pStatus = VCARD_TYPE_VALUE_STATUS;
358 * In current step, TYPE NAME is invalid. So Try to get TYPE NAME again from next position.
360 *pStatus = VCARD_TYPE_NAME_STATUS;
367 * __VCardGetParamName() fine the param name and returns the index number
369 * @param pVCardRaw The raw data
370 * @param pStatus Decoder status
371 * @param pDLen retrived length
373 * @return res The index in type list
376 __VCardGetParamName(char* pVCardRaw, int* pStatus, int* pDLen)
382 char name[MAX_PARAM_NAME_LEN+1] = {0,};
383 char* pTemp = pVCardRaw;
385 SysRequireEx(pVCardRaw, UNKNOWN_NAME);
391 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
394 * PARAM NAME's length is must be less than MAX_PARAM_NAME_LEN.
395 * If PARAM NAME's value is over MAX_PARAM_NAME_LEN, return UNKNOWN_NAME.
396 * And then Decoding Step shoud not be changed.
398 if (index >= MAX_PARAM_NAME_LEN) {
399 *pStatus = VCARD_TYPE_NAME_STATUS;
405 * There is a delimeter between PARAM NAME and next element(=Param, or Param Value).
406 * If VTYPE_TOKEN_EQUAL is faced with,
407 * find PARAM NAME's value in pszCardParamList, and then return searched result.
409 if (c == VTYPE_TOKEN_EQUAL) {
412 UPPER(name, i, index);
413 res = __VCardGetName(name, (char**)pszCardParamList, VCARD_PARAM_NUM);
414 if (res == UNKNOWN_NAME)
417 *pStatus = VCARD_PARAM_VALUE_STATUS;
421 * This case, There is no parameter type. Only Parameter Value.
422 * In VCARD_PARAM_NAME_STATUS status, VTYPE_TOKEN_COLON means that anything parameter is no more.
423 * so set next step to VCARD_PARAM_VALUE_STATUS.
425 * Ex) TEL;WORK:+12341234
426 * ------ ":" next is TEL TYPE's value.
428 * VCARD_PARAM_NAME_STATUS(current) -> VCARD_PARAM_VALUE_STATUS
429 * -> VCARD_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
431 else if (c == VTYPE_TOKEN_COLON) {
432 *pStatus = VCARD_PARAM_VALUE_STATUS;
439 * This case, There is no parameter type. Only Parameter Value.
440 * In VCARD_PARAM_NAME_STATUS status, VTYPE_TOKEN_SEMICOLON means that there is a next parameter.
441 * so set next step to VCARD_PARAM_NAME_STATUS.
443 * Ex) TEL;WORK;PREF:+12341234
444 * ------ ":" next is TEL TYPE's value.
446 * VCARD_PARAM_NAME_STATUS(current) -> VCARD_PARAM_NAME_STATUS
447 * -> VCARD_PARAM_VALUE_STATUS -> VCARD_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
449 else if (c == VTYPE_TOKEN_SEMICOLON) {
450 *pStatus = VCARD_PARAM_NAME_STATUS;
455 } else if ((c == '\r') || (c == '\n') || (_VIsSpace(c))) {
465 __VCardFreeVTreeMemory(VTree * pTree)
468 VObject* pCurObj = NULL;
469 VObject* pNextObj = NULL;
471 VTree* pCurTree = NULL;
472 VTree* pNextTree = NULL;
474 VParam* pCurParam = NULL;
475 VParam* pNextParam = NULL;
480 SysRequireEx(pTree->treeType == VCARD, false);
481 SysRequireEx(pTree != NULL, false);
482 VDATA_TRACE("vcard_free_vtree_memory() entered.");
484 if (pTree->treeType != VCARD) {
492 pNextTree = pCurTree->pNext;
493 pCurObj = pCurTree->pTop;
497 pNextObj = pCurObj->pSibling;
498 count = pCurObj->valueCount;
500 for (i = 0; i < count; i++)
501 VFREE(pCurObj->pszValue[i]);
503 #ifdef VDATA_GROUPNAME_SUPPORTED
504 if (pCurObj->pszGroupName)
505 VFREE(pCurObj->pszGroupName);
508 if (pCurObj->pParam) {
510 pCurParam = pCurObj->pParam;
512 while (pCurParam != NULL) {
513 pNextParam = pCurParam->pNext;
514 VDATA_TRACE("pNEXT ==> %p", pCurParam->pNext);
515 VDATA_TRACE("pPARAM ==> %d", pCurParam->parameter);
516 VDATA_TRACE("pVALUE ==> %d", pCurParam->paramValue);
517 VDATA_TRACE("pCurParam : %p", pCurParam);
518 VDATA_TRACE("pCurParam->parameter : %d", pCurParam->parameter);
519 VDATA_TRACE("pCurParam->paramValue : %d", pCurParam->paramValue);
520 if (pNextParam != NULL) {
521 VDATA_TRACE("pNextParam : %p", pNextParam);
522 VDATA_TRACE("pNextParam->parameter : %d", pNextParam->parameter);
523 VDATA_TRACE("pNextParam->paramValue : %d", pNextParam->paramValue);
526 pCurParam = pNextParam;
535 pCurTree = pNextTree;
538 VDATA_TRACE("exit vcard_free_vtree_memory");
544 * __VCardGetParamVal() fine the param value and returns value.
546 * @param pVCardRaw The raw data
547 * @param pStatus Decoder status
548 * @param pDLen retrived length
550 * @return buffer The result value
553 __VCardGetParamVal(char* pVCardRaw, int* pStatus, int* pDLen)
559 char* pTemp = pVCardRaw;
561 SysRequireEx(pVCardRaw, NULL);
564 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
567 case VTYPE_TOKEN_SEMICOLON:
568 *pStatus = VCARD_PARAM_NAME_STATUS;
570 case VTYPE_TOKEN_COLON:
571 *pStatus = VCARD_TYPE_VALUE_STATUS;
573 case VTYPE_TOKEN_COMMA:
574 *pStatus = VCARD_PARAM_VALUE_STATUS;
577 if (c == VTYPE_TOKEN_SEMICOLON
578 || c == VTYPE_TOKEN_COLON
579 || c == VTYPE_TOKEN_COMMA
588 pBuf = (char *)calloc(1, len);
592 memset(pBuf, 0x00, len);
593 memcpy(pBuf, pTemp, len-1);
601 * __VCardGetTypeVal() fine the type value and returns value.
603 * @param pVCardRaw The raw data
604 * @param status Decoder status
605 * @return buffer The result value
608 __VCardGetTypeVal(char* pVCardRaw, int* pStatus, int* pDLen, int enc, VObject* pType)
615 bool bEscape = false;
619 char* pTemp = pVCardRaw;
620 char* pTmpBuf = NULL;
624 SysRequireEx(pVCardRaw, NULL);
627 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
629 if (c == 0x00) break;
633 /** This case means that there are more type's value. */
634 if (c == VTYPE_TOKEN_SEMICOLON && bEscape == false) {
636 if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
638 memset(pBuf, 0x00, len);
639 memcpy(pBuf, pTemp, len-1);
644 *pStatus = VCARD_TYPE_VALUE_STATUS;
646 /** Base 64 Decoding */
647 if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
649 bufferCount = (len * 6 / 8) + 2;
651 if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
656 memset(pTmpBuf, 0x00, bufferCount);
657 num = _VB64Decode(pTmpBuf, pBuf);
659 if (pType != NULL) pType->numOfBiData = num;
667 /** Quoted Printable Decoding */
668 if (enc & pEncList[2].flag) {
673 if (pBuf[i] == '\n' || pBuf[i] == '\r') {
675 if (pBuf[i] == '\n' || pBuf[i] == '\r')
678 if (pBuf[j-1] == '=') j--;
680 pBuf[j++] = pBuf[i++];
693 else if (bEscape == true && c != VTYPE_TOKEN_SEMICOLON)
695 else if ((c == '\r') || (c == '\n')) {
698 if (c2 == '=' && (enc & pEncList[2].flag)) {
700 if ((c1 == '\r') || (c1 == '\n')) {
705 } else if (__VCardGetTypeName(pVCardRaw, &Status, &Len) != UNKNOWN_NAME) {
707 if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
709 memset(pBuf, 0x00, len);
710 memcpy(pBuf, pTemp, len-1);
715 *pStatus = VCARD_TYPE_NAME_STATUS;
719 if ((c1 == '\r') || (c1 == '\n')) {
724 if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
726 bufferCount = (len * 6 / 8) + 5;
728 if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
733 memset(pTmpBuf, 0x00, bufferCount);
734 num = _VB64Decode(pTmpBuf, pBuf);
737 pType->numOfBiData = num;
745 if (enc & pEncList[2].flag) {
750 if (pBuf[i] == '\n' || pBuf[i] == '\r') {
752 if (pBuf[i] == '\n' || pBuf[i] == '\r')
755 if (pBuf[j-1] == '=') j--;
757 pBuf[j++] = pBuf[i++];
775 VCardGetTypeValue(int index)
778 VDATA_TRACE("VCardGetTypeValue() enter..\n");
780 return pTypeList[index].flag;
784 VCardGetValValue(int index)
787 VDATA_TRACE("VCardGetValValue() enter..\n");
789 return pValueList[index].flag;
793 VCardGetEncValue(int index)
796 VDATA_TRACE("VCardGetEncValue() enter..\n");
798 return pEncList[index].flag;
802 VCardGetCharsetValue(int index)
805 VDATA_TRACE("VCardGetCharsetValue() enter..\n");
807 return pCharsetList[index].flag;
811 * vcard_decode() decode the vCard data and returns vObject struct
813 * @param pVCardRaw The raw data
814 * @return vObject The result value
816 VTree* vcard_decode(char *pCardRaw)
819 char* szValue = NULL;
820 char* szCardBegin = NULL;
821 char* pCardRawTmp = NULL;
822 VTree* pVCard = NULL;
823 VParam* pTmpParam = NULL;
824 VObject* pTemp = NULL;
829 int status = VCARD_TYPE_NAME_STATUS;
834 int param_status = false;
835 int numberedParam = 0;
837 /* int start_status = 0; */
840 bool vcard_ended = false;
842 SysRequireEx(pCardRaw != NULL, NULL);
843 len = strlen(pCardRaw);
844 VDATA_TRACE("length of pCardRaw = %d", len);
846 pCardRaw = _VUnfoldingNoSpecNew(pCardRaw);
847 if (pCardRaw == NULL)
850 pCardRawTmp = pCardRaw;
851 len = _VManySpace2Space(pCardRaw);
853 VDATA_TRACE("ret value of _VManySpace2Space = %d", len);
855 if (!__VIsVcardFile(pCardRaw, CHECK_START)) {
862 while (true && !done) {
865 if ((c == '\0') || done)
869 case VCARD_TYPE_NAME_STATUS:
871 type = __VCardGetTypeName(pCardRaw, &status, &dLen);
878 case VCARD_TYPE_BEGIN:
884 if ((pVCard = (VTree*)calloc(1, sizeof(VTree))) == NULL) {
885 /* start_status = 1; */
889 memset(pVCard, 0x00, sizeof(VTree));
892 szCardBegin = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, NULL);
896 pVCard->treeType = VCARD;
899 pVCard->pNext = NULL;
904 if (strstr(pCardRaw, "VCARD") != NULL) {
909 status = VCARD_TYPE_NAME_STATUS;
919 if (UNKNOWN_NAME == type || type < 0) {
920 status = VCARD_TYPE_NAME_STATUS;
924 if ((pTemp = (VObject*)calloc(1, sizeof(VObject))) == NULL)
927 memset(pTemp, 0, sizeof(VObject));
928 pTemp->property = type;
933 if (pVCard->pTop == NULL) {
934 pVCard->pTop = pTemp;
935 pVCard->pCur = pTemp;
937 pVCard->pCur->pSibling = pTemp;
938 pVCard->pCur = pTemp;
945 param_status = false;
948 #ifdef VDATA_GROUPNAME_SUPPORTED
949 if (gszGroupName != NULL)
950 pVCard->pCur->pszGroupName = gszGroupName;
954 case VCARD_PARAM_NAME_STATUS:
957 param = __VCardGetParamName(pCardRaw, &status, &dLen);
960 if (param_status != true) {
962 if ((pTmpParam = (VParam*)calloc(1, sizeof(VParam))) == NULL)
966 pVCard->pCur->pParam = pTmpParam;
967 memset(pTmpParam, 0x00, sizeof(VParam));
968 VDATA_TRACE("pTmpParam : %p", pTmpParam);
970 if ((pTmpParam->pNext = (VParam*)calloc(1, sizeof(VParam))) == NULL)
973 pTmpParam = pTmpParam->pNext;
974 memset(pTmpParam, 0x00, sizeof(VParam));
975 VDATA_TRACE("pTmpParam : %p", pTmpParam);
978 pTmpParam->parameter = param;
981 case VCARD_PARAM_VALUE_STATUS:
984 switch (pTmpParam->parameter) {
985 case VCARD_PARAM_TYPE:
986 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
987 numberedParam |= __VCardGetValue(szValue, pTypeList, VCARD_TYPE_PARAM_NUM);
989 case VCARD_PARAM_VALUE:
990 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
991 numberedParam |= __VCardGetValue(szValue, pValueList, VCARD_VALUE_PARAM_NUM);
993 case VCARD_PARAM_ENCODING:
994 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
995 numberedParam |= __VCardGetValue(szValue, pEncList, VCARD_ENCODE_PARAM_NUM);
998 case VCARD_PARAM_CHARSET:
999 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1000 numberedParam |= __VCardGetValue(szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM);
1002 case VCARD_PARAM_CONTEXT:
1003 case VCARD_PARAM_LANGUAGE:
1004 /* prevent 7605 08.03.13 */
1005 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1009 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1011 SET_PARAM_VALUE(numberedParam, szValue, pTypeList, VCARD_TYPE_PARAM_NUM, pTmpParam, VCARD_PARAM_TYPE, enc);
1012 SET_PARAM_VALUE(numberedParam, szValue, pValueList, VCARD_VALUE_PARAM_NUM, pTmpParam, VCARD_PARAM_VALUE, enc);
1013 SET_PARAM_VALUE(numberedParam, szValue, pEncList, VCARD_ENCODE_PARAM_NUM, pTmpParam, VCARD_PARAM_ENCODING, enc);
1014 SET_PARAM_VALUE(numberedParam, szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM, pTmpParam, VCARD_PARAM_CHARSET, enc);
1023 VDATA_TRACE("%d, %s, %p", numberedParam, szValue, pTmpParam);
1024 pTmpParam->paramValue = numberedParam;
1025 pTmpParam->pNext = NULL;
1029 case VCARD_TYPE_VALUE_STATUS:
1031 temp = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, pVCard->pCur);
1033 if (valueCount < VDATA_VALUE_COUNT_MAX) {
1034 pVCard->pCur->pszValue[valueCount] = temp;
1036 pVCard->pCur->valueCount = valueCount;
1047 if (pVCard == NULL || pVCard->pTop == NULL)
1060 vcard_free_vtree_memory(pVCard);
1066 * vcard_encode() compares the string and vCard type, parameter value.
1068 * @param pVCardRaw Data which will be encoded
1069 * @return char * Encoded result
1071 char* vcard_encode(VTree *pVCardRaw)
1074 char* pVCardRes = NULL;
1075 char* pTempVCard = NULL;
1076 VObject * pTmpObj = NULL;
1081 int lenTypeList = 0;
1083 LENGTH_TYPE_LIST(pszCardTypeList, lenTypeList);
1085 SysRequireEx(pVCardRaw != NULL, NULL);
1086 SysRequireEx(pVCardRaw->pTop != NULL, NULL);
1087 SysRequireEx(pVCardRaw->pTop->property >= 0, NULL);
1088 SysRequireEx(pVCardRaw->pTop->property < lenTypeList, NULL);
1089 SysRequireEx(pVCardRaw->treeType == VCARD, NULL);
1090 SysRequireEx(pVCardRaw->pTop->valueCount > 0, NULL);
1092 /* VDATA_TRACE("START %d %d", pVCardRaw->pTop->property, lenTypeList); */
1094 for (; cnt < pVCardRaw->pTop->valueCount; cnt++) {
1096 if (pVCardRaw->pTop->pszValue[cnt] == NULL) {
1097 VDATA_TRACE("pVCardRaw->pTop->valueCount : %d", pVCardRaw->pTop->valueCount);
1098 VDATA_TRACE("pVCardRaw->pTop->pszValue[%d] : %s", cnt, pVCardRaw->pTop->pszValue[cnt]);
1103 total += sizeof(char) * (14 + 14);
1104 if ((pVCardRes = (char *)calloc(1, total)) == NULL) {
1105 VDATA_TRACE("vcard_encode:calloc failed\n");
1110 memcpy(pVCardRes, "BEGIN:VCARD\r\n", 14);
1111 g_strlcat(pVCardRes, "VERSION:2.1\r\n", total - strlen(pVCardRes));
1113 pTmpObj = pVCardRaw->pTop;
1116 if (pTmpObj == NULL)
1119 if ((pTemp = __VCardTypeEncode(pTmpObj, pszCardTypeList[pTmpObj->property])) != NULL) {
1120 len = strlen(pTemp);
1121 total += len + sizeof(char) * 10;
1122 if ((pTempVCard = (char*)realloc(pVCardRes, total)) == NULL) {
1123 VDATA_TRACE("vcard_encode():realloc failed\n");
1130 pVCardRes = pTempVCard;
1132 if (strncmp(pTemp, "VERSION", strlen("VERSION")) != 0)
1133 g_strlcat(pVCardRes, pTemp, total - strlen(pVCardRes));
1135 VDATA_TRACE("pTemp : %s", pTemp);
1141 if (pTmpObj->pSibling != NULL)
1142 pTmpObj = pTmpObj->pSibling;
1147 total += sizeof(char) * 12;
1148 if ((pTempVCard = (char *)realloc(pVCardRes, total)) == NULL) {
1149 VDATA_TRACE("vcard_encode:realloc failed\n");
1154 pVCardRes = pTempVCard;
1155 g_strlcat(pVCardRes, "END:VCARD\r\n", total - strlen(pVCardRes));
1162 * VIsVcardFile() verify VCard file.
1164 * @param pVCardRaw Data which will be encoded
1165 * @return int result (true or false)
1168 __VIsVcardFile(char *pCardRaw, int mode)
1171 bool rtnValue = true;
1172 char *pszVcardBegin = "BEGIN:VCARD";
1176 for (i = 0; i < 11; i++)
1177 if (*pszVcardBegin++ != *pCardRaw++)
1190 * vCardTypeEncoder() compares the string and vCard type, parameter value.
1192 * @param typeObj Data which will be encoded
1193 * @param type Name of the type
1194 * @return char * Encoded result
1197 __VCardTypeEncode(VObject *pTypeObj, char *pType)
1202 char* szTypeValue = NULL;
1203 char* szTemp = NULL;
1206 char* pEncode = NULL;
1211 len = strlen(pType);
1212 biLen = pTypeObj->numOfBiData;
1214 #ifdef VDATA_GROUPNAME_SUPPORTED
1215 if (pTypeObj->pszGroupName != NULL)
1216 len += strlen(pTypeObj->pszGroupName) + 1;
1217 #endif /* VDATA_GROUPNAME_SUPPORTED */
1219 if ((szTypeValue = (char *)calloc(1, total += (len+1))) == NULL) {
1220 VDATA_TRACE("__VCardTypeEncode():calloc failed\n");
1224 memset(szTypeValue, '\0', (len+1));
1225 #ifdef VDATA_GROUPNAME_SUPPORTED
1226 if (pTypeObj->pszGroupName != NULL) {
1227 g_strlcat(szTypeValue, pTypeObj->pszGroupName, total - strlen(szTypeValue));
1228 g_strlcat(szTypeValue, ".", total - strlen(szTypeValue));
1230 #endif /* VDATA_GROUPNAME_SUPPORTED */
1231 g_strlcat(szTypeValue, pType, total - strlen(szTypeValue));
1233 pTemp = __VCardParamEncode(pTypeObj, &enc);
1234 if (pTemp != NULL) {
1235 len = strlen(pTemp);
1236 if ((szTemp = (char *)realloc(szTypeValue, (total += len))) == NULL) {
1237 VDATA_TRACE("__VCardTypeEncode():realloc failed\n");
1244 szTypeValue = szTemp;
1246 g_strlcat(szTypeValue, pTemp, total - strlen(szTypeValue));
1251 if ((szTemp = (char *)realloc(szTypeValue, (total += 2))) == NULL) {
1256 szTypeValue = szTemp;
1259 g_strlcat(szTypeValue, ":", total - strlen(szTypeValue));
1263 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1264 for (i = 0; i < pTypeObj->valueCount; i++) {
1266 if (pTypeObj->pszValue[i] != NULL)
1267 len += strlen(pTypeObj->pszValue[i]);
1273 for (i = 0; i < pTypeObj->valueCount; i++) {
1276 if ((pEncode = (char *)calloc(1, len+20)) == NULL) {
1282 memset(pEncode, '\0', len+20);
1284 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1285 g_strlcat(pEncode, pTypeObj->pszValue[i], len+20 - strlen(pEncode));
1288 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1292 strncpy(buf, pTypeObj->pszValue[i], 999);
1294 g_strlcat(pEncode, ";", len+20 - strlen(pEncode));
1295 g_strlcat(pEncode, buf, len+20 - strlen(pEncode));
1299 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1301 g_strlcat(pEncode, "\0\0", len+20 - strlen(pEncode));
1302 len = strlen(pEncode);
1308 if (enc & pEncList[2].flag) {
1309 if ((pRes = (char *)calloc(1, len * 6 + 10)) == NULL) {
1316 _VQPEncode(pRes, pEncode);
1318 } else if (enc & pEncList[1].flag) {
1319 if ((pRes = (char *)calloc(1, (len * 8 / 6) + 4)) == NULL) {
1326 memset(pRes, '\0', ((len * 8 / 6) + 4));
1327 _VB64Encode(pRes, pEncode, biLen);
1330 if ((pRes = (char *)calloc(1, len+30)) == NULL) {
1336 memset(pRes, '\0', (len + 30));
1338 memcpy(pRes, pEncode, len);
1343 if ((szTemp = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL) {
1352 g_strlcat(pRes, "\r\n", 2);
1356 if ((szTemp = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1363 szTypeValue = szTemp;
1366 g_strlcat(szTypeValue, pRes, total - strlen(szTypeValue));
1368 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1369 _VRLSpace(szTypeValue);
1370 _VRTSpace(szTypeValue);
1379 * __VCardParamEncode() Parameter Encoding.
1381 * @param pTypeObj Data which will be encoded
1382 * @param pEnc Name of the type
1385 __VCardParamEncode(VObject* pTypeObj, int* pEnc)
1393 char* szParam = NULL;
1394 char* szTemp = NULL;
1395 VParam* pTemp = NULL;
1396 ValueObj* pList = NULL;
1398 /** Paramter initialize. */
1399 pTemp = pTypeObj->pParam;
1401 /** Momory Allocation for parameter string. */
1402 if (pTemp != NULL) {
1403 if ((szParam = (char*)calloc(1, len += 2)) == NULL) {
1407 memset(szParam, 0x00, 2);
1410 /** appending pamaters. */
1413 if (pTemp == NULL) break;
1417 /** Expand szParam string. For appending.*/
1418 if ((szTemp = (char *)realloc(szParam, len += 15)) == NULL) {
1426 /** appending paramter name. */
1427 g_strlcat(szParam, ";", len - strlen(szParam));
1428 if (pTemp->parameter != VCARD_PARAM_TYPE) {
1429 g_strlcat(szParam, pszCardParamList[pTemp->parameter], len - strlen(szParam));
1430 g_strlcat(szParam, "=", len - strlen(szParam));
1433 /** Set Parameter Value name. */
1434 switch (pTemp->parameter) {
1435 case VCARD_PARAM_ENCODING:
1436 *pEnc = pTemp->paramValue;
1437 shift = VCARD_ENCODE_PARAM_NUM;
1438 pList = pEncList; bSupported = true;
1440 case VCARD_PARAM_TYPE:
1441 shift = VCARD_TYPE_PARAM_NUM;
1442 pList = pTypeList; bSupported = true;
1444 case VCARD_PARAM_VALUE:
1445 shift = VCARD_VALUE_PARAM_NUM;
1446 pList = pValueList; bSupported = true;
1448 case VCARD_PARAM_CHARSET:
1449 shift = VCARD_CHARSET_PARAM_NUM;
1450 pList = pCharsetList; bSupported = true;
1453 if ((szTemp = (char*)realloc(szParam, 5)) == NULL) {
1460 g_strlcat(szParam, "NONE", 5 - strlen(szParam));
1463 /** exchage parameter value's to string.*/
1464 if (bSupported == true) {
1466 for (i = 0, sNum = 0x00000001; i < shift; i++) {
1468 if (pTemp->paramValue & sNum) {
1469 if ((szTemp = (char *)realloc(szParam, (len += (strlen(pList[i].szName) + 2)))) == NULL) {
1477 g_strlcat(szParam, pList[i].szName, len - strlen(szParam));
1478 g_strlcat(szParam, "; ", len - strlen(szParam));
1485 /** remove semicolon from tail. */
1486 for (i = strlen(szParam); i > 0 ; i--) {
1488 if (szParam[i] == ' ' && szParam[i-1] == ';') {
1489 szParam[i-1] = '\0';
1494 if (pTemp->pNext != NULL)
1495 pTemp = pTemp->pNext;
1503 bool vcard_free_vtree_memory(VTree * pTree)
1506 if (pTree == NULL) {
1511 return __VCardFreeVTreeMemory(pTree);