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] : %p, list[%d].szName : %p", i, size, i, list[i], 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]);
504 #ifdef VDATA_GROUPNAME_SUPPORTED
505 if (pCurObj->pszGroupName)
506 VFREE(pCurObj->pszGroupName);
509 if (pCurObj->pParam) {
511 pCurParam = pCurObj->pParam;
513 while (pCurParam != NULL) {
514 pNextParam = pCurParam->pNext;
515 VDATA_TRACE("pNEXT ==> %p", pCurParam->pNext);
516 VDATA_TRACE("pPARAM ==> %p", pCurParam->parameter);
517 VDATA_TRACE("pVALUE ==> %p", pCurParam->paramValue);
518 VDATA_TRACE("pCurParam : %p", pCurParam);
519 VDATA_TRACE("pCurParam->parameter : %d", pCurParam->parameter);
520 VDATA_TRACE("pCurParam->paramValue : %d", pCurParam->paramValue);
521 if (pNextParam != NULL) {
522 VDATA_TRACE("pNextParam : %p", pNextParam);
523 VDATA_TRACE("pNextParam->parameter : %d", pNextParam->parameter);
524 VDATA_TRACE("pNextParam->paramValue : %d", pNextParam->paramValue);
527 pCurParam = pNextParam;
536 pCurTree = pNextTree;
539 VDATA_TRACE("exit vcard_free_vtree_memory");
545 * __VCardGetParamVal() fine the param value and returns value.
547 * @param pVCardRaw The raw data
548 * @param pStatus Decoder status
549 * @param pDLen retrived length
551 * @return buffer The result value
554 __VCardGetParamVal(char* pVCardRaw, int* pStatus, int* pDLen)
560 char* pTemp = pVCardRaw;
562 SysRequireEx(pVCardRaw, NULL);
565 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
568 case VTYPE_TOKEN_SEMICOLON:
569 *pStatus = VCARD_PARAM_NAME_STATUS;
571 case VTYPE_TOKEN_COLON:
572 *pStatus = VCARD_TYPE_VALUE_STATUS;
574 case VTYPE_TOKEN_COMMA:
575 *pStatus = VCARD_PARAM_VALUE_STATUS;
578 if (c == VTYPE_TOKEN_SEMICOLON
579 || c == VTYPE_TOKEN_COLON
580 || c == VTYPE_TOKEN_COMMA
589 pBuf = (char *)calloc(1, len);
593 memset(pBuf, 0x00, len);
594 memcpy(pBuf, pTemp, len-1);
602 * __VCardGetTypeVal() fine the type value and returns value.
604 * @param pVCardRaw The raw data
605 * @param status Decoder status
606 * @return buffer The result value
609 __VCardGetTypeVal(char* pVCardRaw, int* pStatus, int* pDLen, int enc, VObject* pType)
616 bool bEscape = false;
620 char* pTemp = pVCardRaw;
621 char* pTmpBuf = NULL;
625 SysRequireEx(pVCardRaw, NULL);
628 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
630 if (c == 0x00) break;
634 /** This case means that there are more type's value. */
635 if (c == VTYPE_TOKEN_SEMICOLON && bEscape == false) {
637 if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
639 memset(pBuf, 0x00, len);
640 memcpy(pBuf, pTemp, len-1);
645 *pStatus = VCARD_TYPE_VALUE_STATUS;
647 /** Base 64 Decoding */
648 if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
650 bufferCount = (len * 6 / 8) + 2;
652 if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
657 memset(pTmpBuf, 0x00, bufferCount);
658 num = _VB64Decode(pTmpBuf, pBuf);
660 if (pType != NULL) pType->numOfBiData = num;
668 /** Quoted Printable Decoding */
669 if (enc & pEncList[2].flag) {
674 if (pBuf[i] == '\n' || pBuf[i] == '\r') {
676 if (pBuf[i] == '\n' || pBuf[i] == '\r')
679 if (pBuf[j-1] == '=') j--;
681 pBuf[j++] = pBuf[i++];
694 else if (bEscape == true && c != VTYPE_TOKEN_SEMICOLON)
696 else if ((c == '\r') || (c == '\n')) {
699 if (c2 == '=' && (enc & pEncList[2].flag)) {
701 if ((c1 == '\r') || (c1 == '\n')) {
706 } else if (__VCardGetTypeName(pVCardRaw, &Status, &Len) != UNKNOWN_NAME) {
708 if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
710 memset(pBuf, 0x00, len);
711 memcpy(pBuf, pTemp, len-1);
716 *pStatus = VCARD_TYPE_NAME_STATUS;
720 if ((c1 == '\r') || (c1 == '\n')) {
725 if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
727 bufferCount = (len * 6 / 8) + 5;
729 if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
734 memset(pTmpBuf, 0x00, bufferCount);
735 num = _VB64Decode(pTmpBuf, pBuf);
738 pType->numOfBiData = num;
746 if (enc & pEncList[2].flag) {
751 if (pBuf[i] == '\n' || pBuf[i] == '\r') {
753 if (pBuf[i] == '\n' || pBuf[i] == '\r')
756 if (pBuf[j-1] == '=') j--;
758 pBuf[j++] = pBuf[i++];
776 VCardGetTypeValue(int index)
779 VDATA_TRACE("VCardGetTypeValue() enter..\n");
781 return pTypeList[index].flag;
785 VCardGetValValue(int index)
788 VDATA_TRACE("VCardGetValValue() enter..\n");
790 return pValueList[index].flag;
794 VCardGetEncValue(int index)
797 VDATA_TRACE("VCardGetEncValue() enter..\n");
799 return pEncList[index].flag;
803 VCardGetCharsetValue(int index)
806 VDATA_TRACE("VCardGetCharsetValue() enter..\n");
808 return pCharsetList[index].flag;
812 * vcard_decode() decode the vCard data and returns vObject struct
814 * @param pVCardRaw The raw data
815 * @return vObject The result value
818 vcard_decode(char *pCardRaw)
821 char* szValue = NULL;
822 char* szCardBegin = NULL;
823 char* pCardRawTmp = NULL;
824 VTree* pVCard = NULL;
825 VParam* pTmpParam = NULL;
826 VObject* pTemp = NULL;
831 int status = VCARD_TYPE_NAME_STATUS;
836 int param_status = false;
837 int numberedParam = 0;
839 //int start_status = 0;
842 bool vcard_ended = false;
844 SysRequireEx(pCardRaw != NULL, NULL);
845 len = strlen(pCardRaw);
846 VDATA_TRACE("length of pCardRaw = %d", len);
848 pCardRaw = _VUnfoldingNoSpecNew(pCardRaw);
849 if (pCardRaw == NULL) {
852 pCardRawTmp = pCardRaw;
853 len = _VManySpace2Space(pCardRaw);
855 VDATA_TRACE("ret value of _VManySpace2Space = %d", len);
857 if (!__VIsVcardFile(pCardRaw, CHECK_START)) {
864 while (true && !done) {
867 if ((c == '\0') || done)
871 case VCARD_TYPE_NAME_STATUS:
873 type = __VCardGetTypeName(pCardRaw, &status, &dLen);
880 case VCARD_TYPE_BEGIN:
886 if ((pVCard = (VTree*)calloc(1, sizeof(VTree))) == NULL) {
891 memset(pVCard, 0x00, sizeof(VTree));
894 szCardBegin = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, NULL);
898 pVCard->treeType = VCARD;
901 pVCard->pNext = NULL;
906 if (strstr(pCardRaw, "VCARD") != NULL) {
911 status = VCARD_TYPE_NAME_STATUS;
921 if (UNKNOWN_NAME == type || type < 0) {
922 status = VCARD_TYPE_NAME_STATUS;
926 if ((pTemp = (VObject*)calloc(1, sizeof(VObject))) == NULL) {
930 memset(pTemp, 0, sizeof(VObject));
931 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->pTop == NULL)
1060 __VCardFreeVTreeMemory(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
1072 vcard_encode(VTree *pVCardRaw)
1075 char* pVCardRes = 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 ((pVCardRes = (char*)realloc(pVCardRes, total)) == NULL) {
1123 VDATA_TRACE("vcard_encode():realloc failed\n");
1130 if (strncmp(pTemp, "VERSION", strlen("VERSION")) != 0)
1131 g_strlcat(pVCardRes, pTemp, total - strlen(pVCardRes));
1133 VDATA_TRACE("pTemp : %s", pTemp);
1139 if (pTmpObj->pSibling != NULL)
1140 pTmpObj = pTmpObj->pSibling;
1145 total += sizeof(char) * 12;
1146 if ((pVCardRes = (char *)realloc(pVCardRes, total)) == NULL) {
1147 VDATA_TRACE("vcard_encode:realloc failed\n");
1151 g_strlcat(pVCardRes, "END:VCARD\r\n", total - strlen(pVCardRes));
1158 * VIsVcardFile() verify VCard file.
1160 * @param pVCardRaw Data which will be encoded
1161 * @return int result (true or false)
1164 __VIsVcardFile(char *pCardRaw, int mode)
1167 bool rtnValue = true;
1168 char *pszVcardBegin = "BEGIN:VCARD";
1172 for (i = 0; i < 11; i++)
1173 if (*pszVcardBegin++ != *pCardRaw++)
1186 * vCardTypeEncoder() compares the string and vCard type, parameter value.
1188 * @param typeObj Data which will be encoded
1189 * @param type Name of the type
1190 * @return char * Encoded result
1193 __VCardTypeEncode(VObject *pTypeObj, char *pType)
1198 char* szTypeValue = NULL;
1201 char* pEncode = NULL;
1206 len = strlen(pType);
1207 biLen = pTypeObj->numOfBiData;
1209 #ifdef VDATA_GROUPNAME_SUPPORTED
1210 if (pTypeObj->pszGroupName != NULL) {
1211 len += strlen(pTypeObj->pszGroupName) + 1;
1213 #endif // VDATA_GROUPNAME_SUPPORTED
1214 if ((szTypeValue = (char *)calloc(1, total += (len+1))) == NULL) {
1215 VDATA_TRACE("__VCardTypeEncode():calloc failed\n");
1219 memset(szTypeValue, '\0', (len+1));
1220 #ifdef VDATA_GROUPNAME_SUPPORTED
1221 if (pTypeObj->pszGroupName != NULL) {
1222 g_strlcat(szTypeValue, pTypeObj->pszGroupName, total - strlen(szTypeValue));
1223 g_strlcat(szTypeValue, ".", total - strlen(szTypeValue));
1225 #endif // VDATA_GROUPNAME_SUPPORTED
1226 g_strlcat(szTypeValue, pType, total - strlen(szTypeValue));
1228 pTemp = __VCardParamEncode(pTypeObj, &enc);
1229 if (pTemp != NULL) {
1230 len = strlen(pTemp);
1231 if ((szTypeValue = (char *)realloc(szTypeValue, (total += len))) == NULL) {
1232 VDATA_TRACE("__VCardTypeEncode():realloc failed\n");
1238 g_strlcat(szTypeValue, pTemp, total - strlen(szTypeValue));
1243 if ((szTypeValue = (char *)realloc(szTypeValue, (total += 2))) == NULL) {
1248 g_strlcat(szTypeValue, ":", total - strlen(szTypeValue));
1252 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1253 for (i = 0; i < pTypeObj->valueCount; i++) {
1255 if (pTypeObj->pszValue[i] != NULL)
1256 len += strlen(pTypeObj->pszValue[i]);
1262 for (i = 0; i < pTypeObj->valueCount; i++) {
1265 if ((pEncode = (char *)calloc(1, len+20)) == NULL) {
1271 memset(pEncode, '\0', len+20);
1273 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1274 g_strlcat(pEncode, pTypeObj->pszValue[i], len+20 - strlen(pEncode));
1277 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1281 strncpy(buf, pTypeObj->pszValue[i], 999);
1283 g_strlcat(pEncode, ";", len+20 - strlen(pEncode));
1284 g_strlcat(pEncode, buf, len+20 - strlen(pEncode));
1288 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1290 g_strlcat(pEncode, "\0\0", len+20 - strlen(pEncode));
1291 len = strlen(pEncode);
1297 if (enc & pEncList[2].flag) {
1298 if ((pRes = (char *)calloc(1, len * 6 + 10)) == NULL) {
1305 _VQPEncode(pRes, pEncode);
1307 } else if (enc & pEncList[1].flag) {
1308 if ((pRes = (char *)calloc(1, (len * 8 / 6) + 4)) == NULL) {
1315 memset(pRes, '\0', ((len * 8 / 6) + 4));
1316 _VB64Encode(pRes, pEncode, biLen);
1319 if ((pRes = (char *)calloc(1, len+30)) == NULL) {
1325 memset(pRes, '\0', (len + 30));
1327 memcpy(pRes, pEncode, len);
1332 if ((pRes = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL) {
1338 g_strlcat(pRes, "\r\n", 2);
1342 if ((szTypeValue = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1349 g_strlcat(szTypeValue, pRes, total - strlen(szTypeValue));
1351 if (strcmp(pType, pszCardTypeList[19]) != 0) {
1352 _VRLSpace(szTypeValue);
1353 _VRTSpace(szTypeValue);
1362 * __VCardParamEncode() Parameter Encoding.
1364 * @param pTypeObj Data which will be encoded
1365 * @param pEnc Name of the type
1368 __VCardParamEncode(VObject* pTypeObj, int* pEnc)
1376 char* szParam = NULL;
1377 VParam* pTemp = NULL;
1378 ValueObj* pList = NULL;
1380 /** Paramter initialize. */
1381 pTemp = pTypeObj->pParam;
1383 /** Momory Allocation for parameter string. */
1384 if (pTemp != NULL) {
1385 if ((szParam = (char*)calloc(1, len += 2)) == NULL) {
1389 memset(szParam, 0x00, 2);
1392 /** appending pamaters. */
1395 if (pTemp == NULL) break;
1399 /** Expand szParam string. For appending.*/
1400 if ((szParam = (char *)realloc(szParam, len += 15)) == NULL) {
1405 /** appending paramter name. */
1406 g_strlcat(szParam, ";", len - strlen(szParam));
1407 if (pTemp->parameter != VCARD_PARAM_TYPE) {
1408 g_strlcat(szParam, pszCardParamList[pTemp->parameter], len - strlen(szParam));
1409 g_strlcat(szParam, "=", len - strlen(szParam));
1412 /** Set Parameter Value name. */
1413 switch (pTemp->parameter) {
1414 case VCARD_PARAM_ENCODING:
1415 *pEnc = pTemp->paramValue;
1416 shift = VCARD_ENCODE_PARAM_NUM;
1417 pList = pEncList; bSupported = true;
1419 case VCARD_PARAM_TYPE:
1420 shift = VCARD_TYPE_PARAM_NUM;
1421 pList = pTypeList; bSupported = true;
1423 case VCARD_PARAM_VALUE:
1424 shift = VCARD_VALUE_PARAM_NUM;
1425 pList = pValueList; bSupported = true;
1427 case VCARD_PARAM_CHARSET:
1428 shift = VCARD_CHARSET_PARAM_NUM;
1429 pList = pCharsetList; bSupported = true;
1432 if ((szParam = (char*)realloc(szParam, 5)) == NULL) {
1436 g_strlcat(szParam, "NONE", 5 - strlen(szParam));
1439 /** exchage parameter value's to string.*/
1440 if (bSupported == true) {
1442 for (i = 0, sNum = 0x00000001; i < shift; i++) {
1444 if (pTemp->paramValue & sNum) {
1445 if ((szParam = (char *)realloc(szParam, (len += (strlen(pList[i].szName) + 2)))) == NULL) {
1450 g_strlcat(szParam, pList[i].szName, len - strlen(szParam));
1451 g_strlcat(szParam, "; ", len - strlen(szParam));
1458 /** remove semicolon from tail. */
1459 for (i = strlen(szParam); i > 0 ; i--) {
1461 if (szParam[i] == ' ' && szParam[i-1] == ';') {
1462 szParam[i-1] = '\0';
1467 if (pTemp->pNext != NULL)
1468 pTemp = pTemp->pNext;
1477 vcard_free_vtree_memory(VTree * pTree)
1480 if (pTree == NULL) {
1485 return __VCardFreeVTreeMemory(pTree);