2 * Copyright 2012 Samsung Electronics Co., Ltd
4 * Licensed under the Flora License, Version 1.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.tizenopensource.org/license
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[] =
65 "ADR", /* Delivery Address -> address*/
66 "AGENT", /* Agent -> assistant name, assistant number*/
67 "BDAY", /* Birthday -> birthday */
68 "BEGIN", /* BEGIN VCARD DELIMITER*/
69 "CATEGORIES", /* Categories is a multivalued attribute */
71 "EMAIL", /* Email -> email */
72 "END", /* END VCARD DELIMITER*/
73 "FN", /* Formatted Name -> display_name */
74 "GEO", /* Geographic Positioning*/
75 "KEY", /* Public Key*/
76 "LABEL", /* Label Address -> address*/
78 "MAILER", /* Email Program (Optional)*/
79 "N", /* Name -> name */
80 "NAME", /* Name -> name */
81 "NICKNAME", /* Nickname -> nickname */
82 "NOTE", /* Note -> note */
83 "ORG", /* Organization Name or Organizational unit -> department*/
84 "PHOTO", /* Photograph -> caller id*/
87 "REV", /* Last Revision(combination of calendar date & time)*/
88 "ROLE", /* Role or occupation */
92 "TEL", /* Telephone -> phone number */
93 "TITLE", /* Job Title -> job title */
95 "UID", /* Unique Identifier*/
96 "URL", /* URL -> web address */
97 "VERSION", /* Version*/
103 char* pszCardParamList[] =
113 /** Encoding value */
114 ValueObj pEncList[] =
117 {"BASE64", 0x00000002},
118 {"QUOTED-PRINTABLE", 0x00000004},
119 {"7BIT", 0x00000008},
123 /** Character set value */
124 ValueObj pCharsetList[] =
126 {"UTF-8", 0x00000001},
127 {"UTF-16", 0x00000002},
128 {"ISO-8859-1", 0x00000004}
132 ValueObj pValueList[] =
134 {"BINARY", 0x00000001},
135 {"BOOLEAN", 0x00000002},
136 {"DATE", 0x00000004},
137 {"DATE-TIME", 0x00000008},
138 {"FLOAT", 0x00000010},
139 {"INTEGER", 0x00000020},
140 {"PHONE-NUMBER", 0x00000040},
141 {"TEXT", 0x00000080},
142 {"TIME", 0x00000100},
145 {"UTC-OFFSET", 0x00000800},
146 {"VCARD", 0x00001000}
150 ValueObj pTypeList[] =
152 {"AIFF", 0x00000001},
155 {"CELL", 0x00000008},
157 {"WORK", 0x00000020},
160 {"HOME", 0x00000100},
161 {"INTL", 0x00000200},
162 {"INTERNET", 0x00000400},
163 {"ISDN", 0x00000800},
164 {"JPEG", 0x00001000},
165 {"MOBILE", 0x00002000},
166 {"MODEM", 0x00004000},
168 {"PAGER", 0x00010000},
169 {"PARCEL", 0x00020000},
173 {"POSTAL", 0x00200000},
174 {"PREF", 0x00400000},
175 {"VIDEO", 0x00800000},
176 {"VOICE", 0x01000000},
177 {"WAVE", 0x02000000},
178 {"WBMP", 0x04000000},
183 /** FUNCTION DECLARATION */
184 int __VCardGetName(char*, char**, int);
185 int __VCardGetValue(char*, const ValueObj*, int);
186 int __VCardGetTypeName(char*, int*, int*);
187 int __VCardGetParamName(char*, int*, int*);
188 int __VIsVcardFile(char*, int);
189 char* __VCardGetParamVal(char*,int*, int*);
190 char* __VCardGetTypeVal(char*, int*, int*, int, VObject*);
191 char* __VCardTypeEncode(VObject*, char*);
192 char* __VCardParamEncode(VObject*, int*);
194 #ifdef VDATA_GROUPNAME_SUPPORTED
196 #endif // VDATA_GROUPNAME_SUPPORTED
200 * __VCardGetName() compares the string and vCard type, parameter name.
202 * @param szString Name which will compare
203 * @param pszList[] Name list of vCard type and param
204 * @param size Number of total element of list
206 * @return index The index in the list
209 __VCardGetName(char* szString, char* pszList[], int size)
212 int high, low, i, diff;
217 for(; high >= low; diff<0 ? (low = i+1):(high = i-1)) {
218 i = ( low + high ) / 2;
219 if((diff = strcmp( pszList[i], szString )) == 0) /* success: found it */
227 * __VCardGetValue() compares the string and vCard type, parameter value.
229 * @param szString Value which will compare
230 * @param list[] Value list of vCard param
231 * @param size Number of total element of list
233 * @return flag The value's flag.
236 __VCardGetValue( char* szString, const ValueObj list[], int size)
239 int i = 0, diff = -1;
240 char* szTemp = szString;
242 SysRequireEx(szString, UNKNOWN_NAME);
243 SysRequireEx(size > 0, UNKNOWN_NAME);
245 UPPER(szTemp,i,strlen(szTemp));
247 for(i = 0; i < size-1; i++)
249 VDATA_TRACE(" i : %d",i);
250 VDATA_TRACE(" for loop %d < %d, list[%d] : %p, list[%d].szName : %p",i,size,i,list[i],i,list[i].szName);
251 VDATA_TRACE(" i : %d",i);
252 if(list[i].szName != NULL)
254 VDATA_TRACE(" list[%d].szName != NULL",i);
255 VDATA_TRACE(" before strcmp %s %s",list[i].szName,szTemp);
256 VDATA_TRACE(" before strcmp %d",strcmp(list[i].szName, szTemp));
257 if((diff = strcmp(list[i].szName, szTemp)) == 0) /* success: found it */
259 VDATA_TRACE(" return %d",list[i].flag);
263 VDATA_TRACE(" after strcmp %s %s",list[i].szName,szTemp);
266 VDATA_TRACE(" return UNKNOWN_NAME");
272 * __VCardGetTypeName() fine the type name and returns the index number
274 * @param pVCardRaw The raw data
275 * @param pStatus Decoder status
276 * @param pDLen retrived length
278 * @return res The index in type list
281 __VCardGetTypeName(char* pVCardRaw, int* pStatus, int* pDLen)
286 char name[MAX_TYPE_NAME_LEN+1]={0,};
288 #ifdef VDATA_GROUPNAME_SUPPORTED
289 char* szGroupName = NULL;
290 #endif // VDATA_GROUPNAME_SUPPORTED
292 SysRequireEx(pVCardRaw, UNKNOWN_NAME);
299 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
302 * TYPE NAME's length is must be less than MAX_TYPE_NAME_LEN.
303 * If TYPE NAME's value is over MAX_TYPE_NAME_LEN, return UNKNOWN_NAME.
304 * And then Decoding Step shoud not be changed.
306 if(index >= MAX_TYPE_NAME_LEN) {
307 *pStatus = VCARD_TYPE_NAME_STATUS;
313 * There is a delimeter between TYPE NAME and next element(=Param, or Type Value).
314 * If VTYPE_TOKEN_SEMICOLON or VTYPE_TOKEN_COLON is faced with,
315 * find TYPE NAME's value in pszCardTypeList, and then return searched result.
317 if ((c == VTYPE_TOKEN_SEMICOLON ) || ( c == VTYPE_TOKEN_COLON)) {
321 res = __VCardGetName( name, (char**)pszCardTypeList, VCARD_TYPE_NUM );
324 /** current version not support grouping vcard type */
325 else if ( c == VTYPE_TOKEN_DOT ) {
326 #ifdef VDATA_GROUPNAME_SUPPORTED
328 szGroupName = ( char* ) malloc ( index+1 );
329 if(szGroupName != NULL){
330 strncpy( szGroupName, name, index );
331 gszGroupName = szGroupName;
337 * There is no new line in TYPE NAME.
338 * If new line character is faced with, return UNKNOWN_NAME;
340 else if ( ( c == '\r' ) || ( c == '\n' ) )
343 *pStatus = VCARD_TYPE_NAME_STATUS;
347 else if(_VIsSpace(c));
348 else name[index++] = c;
355 if ( c == VTYPE_TOKEN_SEMICOLON )
357 * This case next token is parameter. So set VCARD_PARAM_NAME_STATUS step.
359 *pStatus = VCARD_PARAM_NAME_STATUS;
361 if(res != UNKNOWN_NAME)
363 * This case next string is value. So set VCARD_TYPE_VALUE_STATUS step.
365 *pStatus = VCARD_TYPE_VALUE_STATUS;
368 * In current step, TYPE NAME is invalid. So Try to get TYPE NAME again from next position.
370 *pStatus = VCARD_TYPE_NAME_STATUS;
377 * __VCardGetParamName() fine the param name and returns the index number
379 * @param pVCardRaw The raw data
380 * @param pStatus Decoder status
381 * @param pDLen retrived length
383 * @return res The index in type list
386 __VCardGetParamName( char* pVCardRaw, int* pStatus, int* pDLen )
392 char name[MAX_PARAM_NAME_LEN+1]={0,};
393 char* pTemp = pVCardRaw;
395 SysRequireEx( pVCardRaw, UNKNOWN_NAME );
402 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
405 * PARAM NAME's length is must be less than MAX_PARAM_NAME_LEN.
406 * If PARAM NAME's value is over MAX_PARAM_NAME_LEN, return UNKNOWN_NAME.
407 * And then Decoding Step shoud not be changed.
409 if(index >= MAX_PARAM_NAME_LEN) {
410 *pStatus = VCARD_TYPE_NAME_STATUS;
416 * There is a delimeter between PARAM NAME and next element(=Param, or Param Value).
417 * If VTYPE_TOKEN_EQUAL is faced with,
418 * find PARAM NAME's value in pszCardParamList, and then return searched result.
420 if(c == VTYPE_TOKEN_EQUAL) {
423 UPPER(name, i, index);
424 res = __VCardGetName( name, ( char** )pszCardParamList, VCARD_PARAM_NUM );
425 if(res==UNKNOWN_NAME){
428 *pStatus = VCARD_PARAM_VALUE_STATUS;
432 * This case, There is no parameter type. Only Parameter Value.
433 * In VCARD_PARAM_NAME_STATUS status, VTYPE_TOKEN_COLON means that anything parameter is no more.
434 * so set next step to VCARD_PARAM_VALUE_STATUS.
436 * Ex) TEL;WORK:+12341234
437 * ------ ":" next is TEL TYPE's value.
439 * VCARD_PARAM_NAME_STATUS(current) -> VCARD_PARAM_VALUE_STATUS
440 * -> VCARD_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
442 else if(c == VTYPE_TOKEN_COLON) {
443 *pStatus = VCARD_PARAM_VALUE_STATUS;
450 * This case, There is no parameter type. Only Parameter Value.
451 * In VCARD_PARAM_NAME_STATUS status, VTYPE_TOKEN_SEMICOLON means that there is a next parameter.
452 * so set next step to VCARD_PARAM_NAME_STATUS.
454 * Ex) TEL;WORK;PREF:+12341234
455 * ------ ":" next is TEL TYPE's value.
457 * VCARD_PARAM_NAME_STATUS(current) -> VCARD_PARAM_NAME_STATUS
458 * -> VCARD_PARAM_VALUE_STATUS -> VCARD_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
460 else if(c == VTYPE_TOKEN_SEMICOLON) {
461 *pStatus = VCARD_PARAM_NAME_STATUS;
467 else if((c == '\r') || (c == '\n') || (_VIsSpace(c)));
476 __VCardFreeVTreeMemory(VTree * pTree)
479 VObject* pCurObj = NULL;
480 VObject* pNextObj = NULL;
482 VTree* pCurTree = NULL;
483 VTree* pNextTree = NULL;
485 VParam* pCurParam = NULL;
486 VParam* pNextParam = NULL;
491 SysRequireEx( pTree->treeType == VCARD, false );
492 SysRequireEx( pTree != NULL, false );
493 VDATA_TRACE("vcard_free_vtree_memory() entered.");
495 if (pTree->treeType != VCARD)
505 pNextTree = pCurTree->pNext;
506 pCurObj = pCurTree->pTop;
511 pNextObj = pCurObj->pSibling;
512 count = pCurObj->valueCount;
514 for ( i = 0; i < count; i++ ) {
515 VFREE( pCurObj->pszValue[i]);
518 #ifdef VDATA_GROUPNAME_SUPPORTED
519 if ( pCurObj->pszGroupName )
520 VFREE( pCurObj->pszGroupName );
523 if ( pCurObj->pParam )
526 pCurParam = pCurObj->pParam;
528 while(pCurParam != NULL)
530 pNextParam = pCurParam->pNext;
531 VDATA_TRACE("pNEXT ==> %p", pCurParam->pNext);
532 VDATA_TRACE("pPARAM ==> %p", pCurParam->parameter);
533 VDATA_TRACE("pVALUE ==> %p", pCurParam->paramValue);
534 VDATA_TRACE("pCurParam : %p", pCurParam);
535 VDATA_TRACE("pCurParam->parameter : %d", pCurParam->parameter);
536 VDATA_TRACE("pCurParam->paramValue : %d", pCurParam->paramValue);
537 if(pNextParam != NULL) {
538 VDATA_TRACE("pNextParam : %p", pNextParam);
539 VDATA_TRACE("pNextParam->parameter : %d", pNextParam->parameter);
540 VDATA_TRACE("pNextParam->paramValue : %d", pNextParam->paramValue);
543 pCurParam = pNextParam;
552 pCurTree = pNextTree;
555 VDATA_TRACE("exit vcard_free_vtree_memory");
561 * __VCardGetParamVal() fine the param value and returns value.
563 * @param pVCardRaw The raw data
564 * @param pStatus Decoder status
565 * @param pDLen retrived length
567 * @return buffer The result value
570 __VCardGetParamVal( char* pVCardRaw, int* pStatus, int* pDLen )
576 char* pTemp = pVCardRaw;
578 SysRequireEx( pVCardRaw, NULL );
581 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
584 case VTYPE_TOKEN_SEMICOLON :
585 *pStatus = VCARD_PARAM_NAME_STATUS;
587 case VTYPE_TOKEN_COLON :
588 *pStatus = VCARD_TYPE_VALUE_STATUS;
590 case VTYPE_TOKEN_COMMA :
591 *pStatus = VCARD_PARAM_VALUE_STATUS;
594 if( c == VTYPE_TOKEN_SEMICOLON
595 || c == VTYPE_TOKEN_COLON
596 || c == VTYPE_TOKEN_COMMA
601 pBuf = (char *)malloc(len);
602 if(len < 1 || (pBuf == NULL)) {
610 memset(pBuf, 0x00, len);
611 memcpy( pBuf, pTemp, len-1 );
619 * __VCardGetTypeVal() fine the type value and returns value.
621 * @param pVCardRaw The raw data
622 * @param status Decoder status
623 * @return buffer The result value
626 __VCardGetTypeVal( char* pVCardRaw, int* pStatus, int* pDLen, int enc, VObject* pType)
633 bool bEscape = false;
637 char* pTemp = pVCardRaw;
638 char* pTmpBuf = NULL;
642 SysRequireEx( pVCardRaw, NULL );
646 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
648 if( c == 0x00) break;
652 /** This case means that there are more type's value. */
653 if ( c == VTYPE_TOKEN_SEMICOLON && bEscape == false ) {
655 if((pBuf = (char *)malloc(len)) == NULL) return NULL;
657 memset(pBuf, 0x00, len);
658 memcpy(pBuf,pTemp,len-1);
663 *pStatus = VCARD_TYPE_VALUE_STATUS;
665 /** Base 64 Decoding */
666 if((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
668 bufferCount = (len * 6 / 8) + 2;
670 if((pTmpBuf = (char *)malloc(bufferCount)) == NULL) {
675 memset(pTmpBuf, 0x00, bufferCount);
676 num = _VB64Decode(pTmpBuf, pBuf);
678 if(pType != NULL) pType->numOfBiData = num;
686 /** Quoted Printable Decoding */
687 if(enc & pEncList[2].flag) {
692 if(pBuf[i] == '\n' || pBuf[i] == '\r'){
694 if(pBuf[i] == '\n'|| pBuf[i] == '\r')
697 if(pBuf[j-1] == '=') j--;
700 pBuf[j++] = pBuf[i++];
713 else if(bEscape == true && c != VTYPE_TOKEN_SEMICOLON )
715 else if((c == '\r') || (c == '\n'))
719 if(c2 == '=' && (enc & pEncList[2].flag))
722 if((c1 == '\r') || (c1 == '\n'))
729 else if(__VCardGetTypeName(pVCardRaw, &Status, &Len) != UNKNOWN_NAME)
732 if((pBuf = (char *)malloc(len)) == NULL) return NULL;
734 memset(pBuf, 0x00, len);
735 memcpy(pBuf,pTemp,len-1);
740 *pStatus = VCARD_TYPE_NAME_STATUS;
744 if((c1 == '\r') || (c1 == '\n')) {
749 if((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
751 bufferCount = (len * 6 / 8) + 5;
753 if((pTmpBuf = (char *)malloc(bufferCount)) == NULL) {
758 memset(pTmpBuf, 0x00, bufferCount);
759 num = _VB64Decode(pTmpBuf, pBuf);
762 pType->numOfBiData = num;
770 if(enc & pEncList[2].flag) {
776 if(pBuf[i] == '\n' || pBuf[i] == '\r')
779 if(pBuf[i] == '\n' || pBuf[i] == '\r')
782 if(pBuf[j-1] == '=') j--;
785 pBuf[j++] = pBuf[i++];
803 VCardGetTypeValue( int index )
806 VDATA_TRACE("VCardGetTypeValue() enter..\n");
808 return pTypeList[index].flag;
812 VCardGetValValue( int index )
815 VDATA_TRACE("VCardGetValValue() enter..\n");
817 return pValueList[index].flag;
821 VCardGetEncValue( int index )
824 VDATA_TRACE("VCardGetEncValue() enter..\n");
826 return pEncList[index].flag;
830 VCardGetCharsetValue( int index )
833 VDATA_TRACE("VCardGetCharsetValue() enter..\n");
835 return pCharsetList[index].flag;
839 * vcard_decode() decode the vCard data and returns vObject struct
841 * @param pVCardRaw The raw data
842 * @return vObject The result value
845 vcard_decode( char *pCardRaw )
848 char* szValue = NULL;
849 char* szCardBegin = NULL;
850 char* pCardRawTmp = NULL;
851 VTree* pVCard = NULL;
852 VParam* pTmpParam = NULL;
853 VObject* pTemp = NULL;
858 int status = VCARD_TYPE_NAME_STATUS;
863 int param_status = false;
864 int numberedParam = 0;
866 int start_status = 0;
869 bool vcard_ended = false;
871 SysRequireEx(pCardRaw != NULL, NULL);
872 len = strlen(pCardRaw);
874 pCardRaw = _VUnfoldingNoSpecNew(pCardRaw);
875 pCardRawTmp = pCardRaw;
876 len = _VManySpace2Space( pCardRaw );
878 if(!__VIsVcardFile(pCardRaw, CHECK_START)) {
889 if((c == '\0') || done)
893 case VCARD_TYPE_NAME_STATUS:
895 type = __VCardGetTypeName(pCardRaw, &status, &dLen);
903 case VCARD_TYPE_BEGIN:
904 if(start_status == 1) {
907 if ( ( pVCard = ( VTree* )malloc( sizeof( VTree ) ) ) == NULL ) {
912 memset(pVCard,0x00, sizeof(VTree));
915 szCardBegin = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, NULL);
919 pVCard->treeType = VCARD;
922 pVCard->pNext = NULL;
927 if(strstr(pCardRaw,"VCARD") != NULL) {
933 status = VCARD_TYPE_NAME_STATUS;
943 if(UNKNOWN_NAME == type || type < 0) {
944 status = VCARD_TYPE_NAME_STATUS;
948 if ( ( pTemp = ( VObject* )malloc( sizeof( VObject ) ) ) == NULL ) {
952 memset( pTemp, 0, sizeof( VObject ) );
953 pTemp->property = type;
955 if ( pVCard->pTop == NULL ) {
956 pVCard->pTop = pTemp;
957 pVCard->pCur = pTemp;
960 pVCard->pCur->pSibling = pTemp;
961 pVCard->pCur = pTemp;
968 param_status = false;
971 #ifdef VDATA_GROUPNAME_SUPPORTED
972 if ( gszGroupName != NULL )
973 pVCard->pCur->pszGroupName = gszGroupName;
977 case VCARD_PARAM_NAME_STATUS:
980 param = __VCardGetParamName( pCardRaw, &status, &dLen );
983 if ( param_status != true ) {
985 if ( ( pTmpParam = ( VParam* )malloc( sizeof( VParam ) ) ) == NULL )
989 pVCard->pCur->pParam = pTmpParam;
990 memset( pTmpParam, 0x00, sizeof( VParam ) );
991 VDATA_TRACE("pTmpParam : %p", pTmpParam);
995 if ( ( pTmpParam->pNext = ( VParam* )malloc( sizeof( VParam ) ) ) == NULL )
998 pTmpParam = pTmpParam->pNext;
999 memset( pTmpParam, 0x00, sizeof(VParam));
1000 VDATA_TRACE("pTmpParam : %p", pTmpParam);
1003 pTmpParam->parameter = param;
1006 case VCARD_PARAM_VALUE_STATUS:
1009 switch ( pTmpParam->parameter )
1011 case VCARD_PARAM_TYPE:
1012 szValue = __VCardGetParamVal( pCardRaw, &status, &dLen );
1013 numberedParam |= __VCardGetValue( szValue, pTypeList, VCARD_TYPE_PARAM_NUM );
1015 case VCARD_PARAM_VALUE:
1016 szValue = __VCardGetParamVal( pCardRaw, &status, &dLen );
1017 numberedParam |= __VCardGetValue( szValue, pValueList, VCARD_VALUE_PARAM_NUM );
1019 case VCARD_PARAM_ENCODING:
1020 szValue = __VCardGetParamVal( pCardRaw, &status, &dLen );
1021 numberedParam |= __VCardGetValue( szValue, pEncList, VCARD_ENCODE_PARAM_NUM );
1022 enc = numberedParam;
1024 case VCARD_PARAM_CHARSET:
1025 szValue = __VCardGetParamVal( pCardRaw, &status, &dLen );
1026 numberedParam |= __VCardGetValue( szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM );
1028 case VCARD_PARAM_CONTEXT:
1029 case VCARD_PARAM_LANGUAGE:
1030 // prevent 7605 08.03.13
1031 szValue = __VCardGetParamVal( pCardRaw, &status, &dLen );
1035 szValue = __VCardGetParamVal( pCardRaw, &status, &dLen );
1037 SET_PARAM_VALUE(numberedParam, szValue, pTypeList, VCARD_TYPE_PARAM_NUM, pTmpParam, VCARD_PARAM_TYPE, enc);
1038 SET_PARAM_VALUE(numberedParam, szValue, pValueList, VCARD_VALUE_PARAM_NUM, pTmpParam, VCARD_PARAM_VALUE, enc);
1039 SET_PARAM_VALUE(numberedParam, szValue, pEncList, VCARD_ENCODE_PARAM_NUM, pTmpParam, VCARD_PARAM_ENCODING, enc);
1040 SET_PARAM_VALUE(numberedParam, szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM, pTmpParam, VCARD_PARAM_CHARSET, enc);
1049 VDATA_TRACE("%d, %s, %p",numberedParam, szValue, pTmpParam);
1050 pTmpParam->paramValue = numberedParam;
1051 pTmpParam->pNext = NULL;
1055 case VCARD_TYPE_VALUE_STATUS:
1057 temp = __VCardGetTypeVal( pCardRaw, &status, &dLen, enc, pVCard->pCur);
1059 if(valueCount <= VDATA_VALUE_COUNT_MAX) {
1060 pVCard->pCur->pszValue[valueCount] = temp;
1062 pVCard->pCur->valueCount = valueCount;
1074 if(pVCard->pTop == NULL)
1087 __VCardFreeVTreeMemory(pVCard);
1093 * vcard_encode() compares the string and vCard type, parameter value.
1095 * @param pVCardRaw Data which will be encoded
1096 * @return char * Encoded result
1099 vcard_encode( VTree *pVCardRaw )
1102 char* pVCardRes = NULL;
1103 VObject * pTmpObj = NULL;
1108 int lenTypeList = 0;
1110 LENGTH_TYPE_LIST(pszCardTypeList, lenTypeList);
1112 SysRequireEx(pVCardRaw != NULL, NULL);
1113 SysRequireEx(pVCardRaw->pTop != NULL, NULL);
1114 SysRequireEx(pVCardRaw->pTop->property >= 0, NULL);
1115 SysRequireEx(pVCardRaw->pTop->property < lenTypeList, NULL);
1116 SysRequireEx(pVCardRaw->treeType == VCARD, NULL);
1117 SysRequireEx(pVCardRaw->pTop->valueCount > 0, NULL);
1119 //VDATA_TRACE("START %d %d", pVCardRaw->pTop->property, lenTypeList);
1121 for(;cnt < pVCardRaw->pTop->valueCount;cnt++) {
1123 if(pVCardRaw->pTop->pszValue[cnt] == NULL) {
1124 VDATA_TRACE("pVCardRaw->pTop->valueCount : %d",pVCardRaw->pTop->valueCount);
1125 VDATA_TRACE("pVCardRaw->pTop->pszValue[%d] : %s", cnt, pVCardRaw->pTop->pszValue[cnt]);
1131 if ( ( pVCardRes = ( char * )malloc( sizeof( char ) * ( total += 14 + 14 ) ) ) == NULL )
1133 VDATA_TRACE( "vcard_encode:malloc failed\n" );
1138 memcpy( pVCardRes, "BEGIN:VCARD\r\n", 14 );
1139 strcat( pVCardRes, "VERSION:2.1\r\n" );
1141 pTmpObj = pVCardRaw->pTop;
1148 if ( ( pTemp = __VCardTypeEncode( pTmpObj, pszCardTypeList[pTmpObj->property] ) ) != NULL )
1150 len = strlen( pTemp );
1152 if ( ( pVCardRes = ( char* )realloc( pVCardRes, ( total += len+10 ) ) ) == NULL )
1154 VDATA_TRACE( "vcard_encode():realloc failed\n");
1161 if( strncmp(pTemp,"VERSION", strlen("VERSION")) != 0)
1162 strncat(pVCardRes, pTemp, strlen(pTemp));
1164 VDATA_TRACE("pTemp : %s", pTemp);
1170 if ( pTmpObj->pSibling != NULL )
1171 pTmpObj = pTmpObj->pSibling;
1176 if ( ( pVCardRes = ( char * )realloc( pVCardRes, ( total += 12 ) ) ) == NULL )
1178 VDATA_TRACE( "vcard_encode:realloc failed\n");
1182 strcat( pVCardRes, "END:VCARD\r\n" );
1189 * VIsVcardFile() verify VCard file.
1191 * @param pVCardRaw Data which will be encoded
1192 * @return int result (true or false)
1195 __VIsVcardFile(char *pCardRaw, int mode)
1198 bool rtnValue = true;
1199 char *pszVcardBegin = "BEGIN:VCARD";
1204 for(i=0; i < 11; i++)
1205 if(*pszVcardBegin++ != *pCardRaw++)
1218 * vCardTypeEncoder() compares the string and vCard type, parameter value.
1220 * @param typeObj Data which will be encoded
1221 * @param type Name of the type
1222 * @return char * Encoded result
1225 __VCardTypeEncode( VObject *pTypeObj, char *pType )
1230 char* szTypeValue = NULL;
1233 char* pEncode = NULL;
1238 len = strlen( pType );
1239 biLen = pTypeObj->numOfBiData;
1241 #ifdef VDATA_GROUPNAME_SUPPORTED
1242 if ( pTypeObj->pszGroupName != NULL )
1244 len += strlen( pTypeObj->pszGroupName ) + 1;
1246 #endif // VDATA_GROUPNAME_SUPPORTED
1247 if ( ( szTypeValue = ( char * )malloc( total += ( len+1 ) ) ) == NULL )
1249 VDATA_TRACE( "__VCardTypeEncode():malloc failed\n");
1253 memset( szTypeValue, '\0', ( len+1 ) );
1254 #ifdef VDATA_GROUPNAME_SUPPORTED
1255 if ( pTypeObj->pszGroupName != NULL )
1257 strcat( szTypeValue, pTypeObj->pszGroupName );
1258 strcat( szTypeValue, "." );
1260 #endif // VDATA_GROUPNAME_SUPPORTED
1261 strcat( szTypeValue, pType );
1263 pTemp = __VCardParamEncode( pTypeObj, &enc );
1264 if ( pTemp != NULL )
1266 len = strlen( pTemp );
1267 if ( ( szTypeValue = ( char * )realloc( szTypeValue, ( total += len ) ) ) == NULL )
1269 VDATA_TRACE( "__VCardTypeEncode():realloc failed\n");
1275 strcat( szTypeValue, pTemp );
1280 if ( ( szTypeValue = ( char * )realloc( szTypeValue, ( total += 2 ) ) ) == NULL )
1286 strcat( szTypeValue, ":" );
1290 if(strcmp(pType, pszCardTypeList[19]) != 0) {
1291 for ( i = 0; i < pTypeObj->valueCount; i++ ) {
1293 if(pTypeObj->pszValue[i] != NULL)
1294 len += strlen( pTypeObj->pszValue[i] );
1301 for ( i = 0; i < pTypeObj->valueCount; i++ ) {
1304 if ( ( pEncode = ( char * )malloc( len+20 ) ) == NULL ) {
1310 memset( pEncode, '\0', len+20 );
1312 if(strcmp(pType, pszCardTypeList[19]) != 0) {
1313 strcat( pEncode, pTypeObj->pszValue[i] );
1317 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1321 strncpy( buf, pTypeObj->pszValue[i], 999 );
1323 strcat( pEncode, ";" );
1324 strcat( pEncode, buf );
1328 if(strcmp(pType, pszCardTypeList[19]) != 0) {
1330 strcat( pEncode, "\0\0" );
1331 len = strlen( pEncode );
1338 if ( enc & pEncList[2].flag ) {
1339 if((pRes = (char *)malloc(len * 6 + 10)) == NULL) {
1346 _VQPEncode( pRes, pEncode );
1349 else if(enc & pEncList[1].flag ) {
1350 if((pRes = (char *)malloc((len * 8 / 6) + 4)) == NULL){
1357 memset( pRes, '\0', ( ( len * 8 / 6 ) + 4 ) );
1358 _VB64Encode( pRes, pEncode, biLen );
1362 if((pRes = (char *)malloc(len+30)) == NULL) {
1368 memset( pRes, '\0', ( len + 30 ) );
1371 memcpy( pRes, pEncode, len );
1376 if((pRes = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL)
1383 strncat( pRes, "\r\n", strlen(pRes) + 2);
1385 len = strlen( pRes );
1387 if ((szTypeValue = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1394 strncat(szTypeValue, pRes, total - 1);
1396 if(strcmp(pType, pszCardTypeList[19]) != 0) {
1397 _VRLSpace( szTypeValue );
1398 _VRTSpace( szTypeValue );
1407 * __VCardParamEncode() Parameter Encoding.
1409 * @param pTypeObj Data which will be encoded
1410 * @param pEnc Name of the type
1413 __VCardParamEncode(VObject* pTypeObj, int* pEnc)
1421 char* szParam = NULL;
1422 VParam* pTemp = NULL;
1423 ValueObj* pList = NULL;
1425 /** Paramter initialize. */
1426 pTemp = pTypeObj->pParam;
1428 /** Momory Allocation for parameter string. */
1430 if ((szParam = (char*)malloc(len+=2)) == NULL)
1435 memset(szParam, 0x00, 2);
1438 /** appending pamaters. */
1441 if(pTemp == NULL) break;
1445 /** Expand szParam string. For appending.*/
1446 if((szParam = (char *)realloc(szParam, len += 15)) == NULL)
1452 /** appending paramter name. */
1453 strcat( szParam, ";" );
1454 if(pTemp->parameter != VCARD_PARAM_TYPE) {
1455 strcat( szParam, pszCardParamList[pTemp->parameter] );
1456 strcat( szParam, "=" );
1459 /** Set Parameter Value name. */
1460 switch ( pTemp->parameter )
1462 case VCARD_PARAM_ENCODING:
1463 *pEnc = pTemp->paramValue;
1464 shift = VCARD_ENCODE_PARAM_NUM;
1465 pList = pEncList; bSupported = true;
1467 case VCARD_PARAM_TYPE:
1468 shift = VCARD_TYPE_PARAM_NUM;
1469 pList = pTypeList; bSupported = true;
1471 case VCARD_PARAM_VALUE:
1472 shift = VCARD_VALUE_PARAM_NUM;
1473 pList = pValueList; bSupported = true;
1475 case VCARD_PARAM_CHARSET:
1476 shift = VCARD_CHARSET_PARAM_NUM;
1477 pList = pCharsetList; bSupported = true;
1480 if ( ( szParam = ( char* )realloc( szParam, 5 ) ) == NULL )
1485 strcat( szParam, "NONE" );
1488 /** exchage parameter value's to string.*/
1489 if(bSupported == true) {
1491 for(i = 0, sNum = 0x00000001; i < shift; i++) {
1493 if(pTemp->paramValue & sNum) {
1494 if((szParam = (char *)realloc(szParam, ( len += (strlen(pList[i].szName) + 2)))) == NULL)
1500 strcat( szParam, pList[i].szName );
1501 strcat( szParam, "; " );
1508 /** remove semicolon from tail. */
1509 for(i = strlen( szParam ); i > 0 ; i--) {
1511 if ( szParam[i] == ' ' && szParam[i-1] == ';' ) {
1512 szParam[i-1] = '\0';
1517 if ( pTemp->pNext != NULL )
1518 pTemp = pTemp->pNext;
1527 vcard_free_vtree_memory(VTree * pTree)
1536 return __VCardFreeVTreeMemory(pTree);