vobject-engine/VCard.c

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15 */
  16
  17 #include "VTypes.h"
  18 #include "VCard.h"
  19 #include "vobject.h"
  20
  21 #define MAX_TYPE_NAME_LEN 50
  22 #define MAX_PARAM_NAME_LEN 50
  23 #define CHECK_START 1
  24 #define CHECK_END 2
  25
  26 #define VFREE(obj) if (obj != NULL) { /*VDATA_TRACE("%p",obj);*/ free(obj); \
  27         obj = NULL; \
  28 }
  29
  30 #define TRIM(obj) if (obj != NULL) {\
  31         _VRLSpace(obj);\
  32         _VRTSpace(obj);\
  33 }
  34
  35 #define UPPER(obj, start, end) if (obj != NULL) {\
  36         for (start = 0; start < end; start++)\
  37                 obj[start] = toupper(obj[start]);\
  38 }
  39
  40 #define GO_NEXT_CHAR(current, rowData, addedCnt) {\
  41         current = *rowData;\
  42         rowData++;\
  43         (*addedCnt)++;\
  44 }
  45
  46 #define SET_PARAM_VALUE(PARAM, SZVALUE, LIST, LISTCNT, PARAMOBJ, PTYPE, ENC) {\
  47         PARAM = 0;\
  48         PARAM |= __VCardGetValue(SZVALUE, LIST, LISTCNT);\
  49         if (PARAM != UNKNOWN_NAME) {\
  50                 PARAMOBJ->parameter = PTYPE;\
  51                 if (PTYPE == VCARD_PARAM_ENCODING)\
  52                         ENC = PARAM;\
  53                 break;\
  54         } \
  55 }
  56
  57 #define LENGTH_TYPE_LIST(obj, len) for (len = 0; obj[len] != NULL; len++);
  58
  59 extern char* _VUnfoldingNoSpecNew(char *string);
  60
  61 /** GLOBAL VARIABLE DECLARATION AND INITIALIZATION */
  62 /** vCard Types. */
  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 */
  69         "CLASS",                        /* */
  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*/
  76         "LOGO",                 /* Logo*/
  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*/
  84         "PRODID",               /* */
  85         "PROFILE",              /* */
  86         "REV",                  /* Last Revision(combination of calendar date & time)*/
  87         "ROLE",                 /* Role or occupation */
  88         "SORT-STRING",  /* */
  89         "SOUND",                        /* Sound*/
  90         "SOURCE",               /* */
  91         "TEL",                  /* Telephone -> phone number */
  92         "TITLE",                        /* Job Title -> job title */
  93         "TZ",                   /* Time Zone*/
  94         "UID",                  /* Unique Identifier*/
  95         "URL",                  /* URL -> web address */
  96         "VERSION",              /* Version*/
  97         "X-IRMC-LUID",  /* */
  98         NULL
  99 };
 100
 101 /** Parameter */
 102 char* pszCardParamList[] = {
 103         "CHARSET",
 104         "CONTEXT",
 105         "ENCODING",
 106         "LANGUAGE",
 107         "TYPE",
 108         "VALUE"
 109 };
 110
 111 /** Encoding value */
 112 ValueObj pEncList[] = {
 113         {"B",                   0x00000001},
 114         {"BASE64",      0x00000002},
 115         {"QUOTED-PRINTABLE", 0x00000004},
 116         {"7BIT",                0x00000008},
 117         {"8BIT",                0x00000010}
 118 };
 119
 120 /** Character set value */
 121 ValueObj pCharsetList[] = {
 122         {"UTF-8",                       0x00000001},
 123         {"UTF-16",              0x00000002},
 124         {"ISO-8859-1",  0x00000004}
 125 };
 126
 127 /** Value value */
 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},
 138         {"URI",                                 0x00000200},
 139         {"URL",                                 0x00000400},
 140         {"UTC-OFFSET",          0x00000800},
 141         {"VCARD",                               0x00001000}
 142 };
 143
 144 /** Type value */
 145 ValueObj pTypeList[] = {
 146         {"AIFF",                0x00000001},
 147         {"BBS",                 0x00000002},
 148         {"CAR",                 0x00000004},
 149         {"CELL",                0x00000008},
 150         {"DOM",                 0x00000010},
 151         {"WORK",                0x00000020},
 152         {"FAX",                 0x00000040},
 153         {"GIF",                 0x00000080},
 154         {"HOME",                0x00000100},
 155         {"INTL",                0x00000200},
 156         {"INTERNET",    0x00000400},
 157         {"ISDN",                0x00000800},
 158         {"JPEG",                0x00001000},
 159         {"MOBILE",      0x00002000},
 160         {"MODEM",               0x00004000},
 161         {"MSG",                 0x00008000},
 162         {"PAGER",               0x00010000},
 163         {"PARCEL",      0x00020000},
 164         {"PCM",                 0x00040000},
 165         {"PCS",                 0x00080000},
 166         {"PNG",                 0x00100000},
 167         {"POSTAL",      0x00200000},
 168         {"PREF",                0x00400000},
 169         {"VIDEO",               0x00800000},
 170         {"VOICE",               0x01000000},
 171         {"WAVE",                0x02000000},
 172         {"WBMP",                0x04000000},
 173         {"ETC",                 0x08000000},
 174         {"X400",                0x10000000}
 175 };
 176
 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*);
 187
 188 #ifdef VDATA_GROUPNAME_SUPPORTED
 189 char*   gszGroupName;
 190 #endif /* VDATA_GROUPNAME_SUPPORTED */
 191
 192
 193 /**
 194  * __VCardGetName() compares the string and vCard type, parameter name.
 195  *
 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
 199  *
 200  * @return              index                   The index in the list
 201  */
 202 int
 203 __VCardGetName(char* szString, char* pszList[], int size)
 204 {
 205         VDATA_TRACE_BEGINE
 206         int high, low, i, diff;
 207
 208         low = 0;
 209         high = size - 1;
 210
 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 */
 214                         return i;
 215         }
 216         VDATA_TRACE_END
 217         return UNKNOWN_NAME;
 218 }
 219
 220 /**
 221  * __VCardGetValue() compares the string and vCard type, parameter value.
 222  *
 223  * @param               szString        Value which will compare
 224  * @param               list[]          Value list of vCard param
 225  * @param               size            Number of total element of list
 226  *
 227  * @return              flag            The value's flag.
 228  */
 229 int
 230 __VCardGetValue(char* szString, const ValueObj list[], int size)
 231 {
 232         VDATA_TRACE_BEGINE
 233         int i = 0, diff = -1;
 234         char* szTemp = szString;
 235
 236         SysRequireEx(szString, UNKNOWN_NAME);
 237         SysRequireEx(size > 0, UNKNOWN_NAME);
 238
 239         UPPER(szTemp, i, strlen(szTemp));
 240
 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);
 251                                 VDATA_TRACE_END
 252                                 return list[i].flag;
 253                         }
 254                         VDATA_TRACE(" after strcmp %s %s", list[i].szName, szTemp);
 255                 }
 256         }
 257         VDATA_TRACE(" return UNKNOWN_NAME");
 258         VDATA_TRACE_END
 259         return UNKNOWN_NAME;
 260 }
 261
 262 /**
 263  * __VCardGetTypeName() fine the type name and returns the index number
 264  *
 265  * @param               pVCardRaw       The raw data
 266  * @param               pStatus Decoder status
 267  * @param               pDLen           retrived length
 268  *
 269  * @return              res                     The index in type list
 270  */
 271 int
 272 __VCardGetTypeName(char* pVCardRaw, int* pStatus, int* pDLen)
 273 {
 274         VDATA_TRACE_BEGINE
 275         int     i, index, res;
 276         char    c;
 277         char    name[MAX_TYPE_NAME_LEN+1] = {0,};
 278
 279 #ifdef VDATA_GROUPNAME_SUPPORTED
 280         char*   szGroupName = NULL;
 281 #endif /* VDATA_GROUPNAME_SUPPORTED */
 282
 283         SysRequireEx(pVCardRaw, UNKNOWN_NAME);
 284
 285         i = index = 0;
 286         res = UNKNOWN_NAME;
 287
 288         while (true) {
 289
 290                 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
 291
 292                 /**
 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.
 296                  */
 297                 if (index >= MAX_TYPE_NAME_LEN) {
 298                         *pStatus = VCARD_TYPE_NAME_STATUS;
 299                         res = UNKNOWN_NAME;
 300                         break;
 301                 }
 302
 303                 /**
 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.
 307                  */
 308                 if ((c == VTYPE_TOKEN_SEMICOLON) || (c == VTYPE_TOKEN_COLON)) {
 309                         name[index] = 0x00;
 310                         TRIM(name);
 311                         UPPER(name, i, index);
 312                         res = __VCardGetName(name, (char**)pszCardTypeList, VCARD_TYPE_NUM);
 313                         break;
 314                 }
 315                 /** current version not support grouping vcard type */
 316                 else if (c == VTYPE_TOKEN_DOT) {
 317 #ifdef VDATA_GROUPNAME_SUPPORTED
 318                         name[index] = '\0';
 319                         szGroupName = (char*) calloc(1,  index+1);
 320                         if (szGroupName != NULL) {
 321                                 strncpy(szGroupName, name, index);
 322                                 gszGroupName = szGroupName;
 323                         }
 324                         index = 0;
 325 #endif
 326                 }
 327                 /**
 328                  * There is no new line in TYPE NAME.
 329                  * If new line character is faced with, return UNKNOWN_NAME;
 330                  */
 331                 else if ((c == '\r') || (c == '\n')) {
 332                         (*pDLen)++;
 333                         *pStatus = VCARD_TYPE_NAME_STATUS;
 334                         res = UNKNOWN_NAME;
 335                         return res;
 336                 } else if (_VIsSpace(c)) {
 337                 } else
 338                         name[index++] = c;
 339         }
 340
 341         /**
 342          *      Set Next Step.
 343          *
 344          */
 345         if (c == VTYPE_TOKEN_SEMICOLON)
 346                 /**
 347                  * This case next token is parameter. So set VCARD_PARAM_NAME_STATUS step.
 348                  */
 349                 *pStatus = VCARD_PARAM_NAME_STATUS;
 350         else {
 351                 if (res != UNKNOWN_NAME)
 352                         /**
 353                          * This case next string is value. So set VCARD_TYPE_VALUE_STATUS step.
 354                          */
 355                         *pStatus = VCARD_TYPE_VALUE_STATUS;
 356                 else
 357                         /**
 358                          * In current step, TYPE NAME is invalid. So Try to get TYPE NAME again from next position.
 359                          */
 360                         *pStatus = VCARD_TYPE_NAME_STATUS;
 361         }
 362         VDATA_TRACE_END
 363         return res;
 364 }
 365
 366 /**
 367  * __VCardGetParamName() fine the param name and returns the index number
 368  *
 369  * @param               pVCardRaw       The raw data
 370  * @param               pStatus Decoder status
 371  * @param               pDLen           retrived length
 372  *
 373  * @return              res                     The index in type list
 374  */
 375 int
 376 __VCardGetParamName(char* pVCardRaw, int* pStatus, int* pDLen)
 377 {
 378         VDATA_TRACE_BEGINE
 379         int     i, index, res;
 380
 381         char    c;
 382         char    name[MAX_PARAM_NAME_LEN+1] = {0,};
 383         char* pTemp = pVCardRaw;
 384
 385         SysRequireEx(pVCardRaw, UNKNOWN_NAME);
 386
 387         i = index = 0;
 388         res = UNKNOWN_NAME;
 389
 390         while (true) {
 391                 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
 392
 393                 /**
 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.
 397                  */
 398                 if (index >= MAX_PARAM_NAME_LEN) {
 399                         *pStatus = VCARD_TYPE_NAME_STATUS;
 400                         res = UNKNOWN_NAME;
 401                         break;
 402                 }
 403
 404                 /**
 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.
 408                  */
 409                 if (c == VTYPE_TOKEN_EQUAL) {
 410                         name[index] = '\0';
 411                         TRIM(name);
 412                         UPPER(name, i, index);
 413                         res = __VCardGetName(name, (char**)pszCardParamList, VCARD_PARAM_NUM);
 414                         if (res == UNKNOWN_NAME)
 415                                 (*pDLen) = 0;
 416
 417                         *pStatus = VCARD_PARAM_VALUE_STATUS;
 418                         break;
 419                 }
 420                 /**
 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.
 424                  *
 425                  * Ex) TEL;WORK:+12341234
 426                  *        ------ ":" next is TEL TYPE's value.
 427                  *
 428                  * VCARD_PARAM_NAME_STATUS(current) -> VCARD_PARAM_VALUE_STATUS
 429                  * -> VCARD_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
 430                  */
 431                 else if (c == VTYPE_TOKEN_COLON) {
 432                         *pStatus = VCARD_PARAM_VALUE_STATUS;
 433                         pVCardRaw = pTemp;
 434                         (*pDLen) = 0;
 435                         res = UNKNOWN_NAME;
 436                         break;
 437                 }
 438                 /**
 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.
 442                  *
 443                  * Ex) TEL;WORK;PREF:+12341234
 444                  *        ------ ":" next is TEL TYPE's value.
 445                  *
 446                  * VCARD_PARAM_NAME_STATUS(current) -> VCARD_PARAM_NAME_STATUS
 447                  * -> VCARD_PARAM_VALUE_STATUS -> VCARD_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
 448                  */
 449                 else if (c == VTYPE_TOKEN_SEMICOLON) {
 450                         *pStatus = VCARD_PARAM_NAME_STATUS;
 451                         pVCardRaw = pTemp;
 452                         (*pDLen) = 0;
 453                         res = UNKNOWN_NAME;
 454                         break;
 455                 } else if ((c == '\r') || (c == '\n') || (_VIsSpace(c))) {
 456
 457                 } else
 458                         name[index++] = c;
 459         }
 460         VDATA_TRACE_END
 461         return res;
 462 }
 463
 464 bool
 465 __VCardFreeVTreeMemory(VTree * pTree)
 466 {
 467         VDATA_TRACE_BEGINE
 468         VObject*                pCurObj = NULL;
 469         VObject*                pNextObj = NULL;
 470
 471         VTree*                  pCurTree = NULL;
 472         VTree*                  pNextTree = NULL;
 473
 474         VParam* pCurParam = NULL;
 475         VParam* pNextParam = NULL;
 476
 477         int count = 0;
 478         int i = 0;
 479
 480         SysRequireEx(pTree->treeType == VCARD, false);
 481         SysRequireEx(pTree != NULL, false);
 482         VDATA_TRACE("vcard_free_vtree_memory() entered.");
 483
 484         if (pTree->treeType != VCARD) {
 485                 VDATA_TRACE_END
 486                 return true;
 487         }
 488
 489         pCurTree = pTree;
 490
 491         while (pCurTree) {
 492                 pNextTree = pCurTree->pNext;
 493                 pCurObj = pCurTree->pTop;
 494
 495                 while (pCurObj) {
 496
 497                         pNextObj = pCurObj->pSibling;
 498                         count = pCurObj->valueCount;
 499
 500                         for (i = 0; i < count; i++)
 501                                 VFREE(pCurObj->pszValue[i]);
 502
 503 #ifdef VDATA_GROUPNAME_SUPPORTED
 504                         if (pCurObj->pszGroupName)
 505                                 VFREE(pCurObj->pszGroupName);
 506 #endif
 507
 508                         if (pCurObj->pParam) {
 509
 510                                 pCurParam = pCurObj->pParam;
 511
 512                                 while (pCurParam != NULL) {
 513                                         pNextParam = pCurParam->pNext;
 514                                         VDATA_TRACE("pNEXT ==> %p", pCurParam->pNext);
 515                                         VDATA_TRACE("pPARAM ==> %p", pCurParam->parameter);
 516                                         VDATA_TRACE("pVALUE ==> %p", 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);
 524                                         }
 525                                         VFREE(pCurParam);
 526                                         pCurParam = pNextParam;
 527                                 }
 528                         }
 529
 530                         VFREE(pCurObj);
 531                         pCurObj = pNextObj;
 532                 }
 533
 534                 VFREE(pCurTree);
 535                 pCurTree = pNextTree;
 536         }
 537
 538         VDATA_TRACE("exit vcard_free_vtree_memory");
 539         VDATA_TRACE_END
 540         return true;
 541 }
 542
 543 /**
 544  * __VCardGetParamVal() fine the param value and returns value.
 545  *
 546  * @param               pVCardRaw       The raw data
 547  * @param               pStatus Decoder status
 548  * @param               pDLen           retrived length
 549  *
 550  * @return              buffer          The result value
 551  */
 552 char*
 553 __VCardGetParamVal(char* pVCardRaw, int* pStatus, int* pDLen)
 554 {
 555         VDATA_TRACE_BEGINE
 556         int len = 0;
 557         char    c;
 558         char* pBuf = NULL;
 559         char* pTemp = pVCardRaw;
 560
 561         SysRequireEx(pVCardRaw, NULL);
 562
 563         while (true) {
 564                 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
 565                 len++;
 566                 switch (c) {
 567                 case VTYPE_TOKEN_SEMICOLON:
 568                         *pStatus = VCARD_PARAM_NAME_STATUS;
 569                         break;
 570                 case VTYPE_TOKEN_COLON:
 571                         *pStatus = VCARD_TYPE_VALUE_STATUS;
 572                         break;
 573                 case VTYPE_TOKEN_COMMA:
 574                         *pStatus = VCARD_PARAM_VALUE_STATUS;
 575                         break;
 576                 }
 577                 if (c == VTYPE_TOKEN_SEMICOLON
 578                                 || c == VTYPE_TOKEN_COLON
 579                                 || c == VTYPE_TOKEN_COMMA
 580                                 || c == 0x00)
 581                         break;
 582         }
 583
 584         /* if (len < 1)
 585                 return NULL;
 586         */
 587
 588         pBuf = (char *)calloc(1, len);
 589         if (pBuf  == NULL)
 590                 return NULL;
 591
 592         memset(pBuf, 0x00, len);
 593         memcpy(pBuf, pTemp, len-1);
 594         TRIM(pBuf);
 595         VDATA_TRACE_END
 596         return pBuf;
 597 }
 598
 599
 600 /**
 601  * __VCardGetTypeVal() fine the type value and returns value.
 602  *
 603  * @param               pVCardRaw               The raw data
 604  * @param               status                  Decoder status
 605  * @return              buffer                  The result value
 606  */
 607 char*
 608 __VCardGetTypeVal(char* pVCardRaw, int* pStatus, int* pDLen, int enc, VObject* pType)
 609 {
 610         VDATA_TRACE_BEGINE
 611         int num = 0;
 612         int len = 0;
 613         int bufferCount = 0;
 614
 615         bool bEscape = false;
 616
 617         char    c, c1, c2;
 618         char* pBuf = NULL;
 619         char* pTemp = pVCardRaw;
 620         char* pTmpBuf = NULL;
 621         int Status = 0;
 622         int Len = 0;
 623
 624         SysRequireEx(pVCardRaw, NULL);
 625
 626         while (true) {
 627                 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
 628
 629                 if (c == 0x00) break;
 630
 631                 len++;
 632
 633                 /** This case means that there are more type's value. */
 634                 if (c == VTYPE_TOKEN_SEMICOLON && bEscape == false) {
 635
 636                         if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
 637
 638                         memset(pBuf, 0x00, len);
 639                         memcpy(pBuf, pTemp, len-1);
 640
 641                         TRIM(pBuf);
 642                         _VUnescape(pBuf);
 643
 644                         *pStatus = VCARD_TYPE_VALUE_STATUS;
 645
 646                         /** Base 64 Decoding */
 647                         if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
 648
 649                                 bufferCount = (len * 6 / 8) + 2;
 650
 651                                 if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
 652                                         VFREE(pBuf);
 653                                         return NULL;
 654                                 }
 655
 656                                 memset(pTmpBuf, 0x00, bufferCount);
 657                                 num = _VB64Decode(pTmpBuf, pBuf);
 658
 659                                 if (pType != NULL) pType->numOfBiData = num;
 660
 661                                 VFREE(pBuf);
 662                                 pBuf = pTmpBuf;
 663                                 pTmpBuf = NULL;
 664                                 break;
 665                         }
 666
 667                         /** Quoted Printable Decoding */
 668                         if (enc & pEncList[2].flag) {
 669
 670                                 int i = 0, j = 0;
 671
 672                                 while (pBuf[i]) {
 673                                         if (pBuf[i] == '\n' || pBuf[i] == '\r') {
 674                                                 i++;
 675                                                 if (pBuf[i] == '\n' || pBuf[i] == '\r')
 676                                                         i++;
 677
 678                                                 if (pBuf[j-1] == '=') j--;
 679                                         } else
 680                                                 pBuf[j++] = pBuf[i++];
 681                                 }
 682                                 pBuf[j] = '\0';
 683
 684                                 _VQPDecode(pBuf);
 685                                 TRIM(pBuf);
 686                                 break;
 687                         }
 688                         break;
 689                 }
 690
 691                 if (c == '\\')
 692                         bEscape = true;
 693                 else if (bEscape == true && c != VTYPE_TOKEN_SEMICOLON)
 694                         bEscape = false;
 695                 else if ((c == '\r') || (c == '\n')) {
 696                         c2 = *(pVCardRaw-2);
 697
 698                         if (c2 == '=' && (enc & pEncList[2].flag)) {
 699                                 c1 = *pVCardRaw;
 700                                 if ((c1 == '\r') || (c1 == '\n')) {
 701                                         pVCardRaw += 1;
 702                                         (*pDLen) += 1;
 703                                         len++;
 704                                 }
 705                         } else if (__VCardGetTypeName(pVCardRaw, &Status, &Len) != UNKNOWN_NAME) {
 706                                 --len;
 707                                 if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
 708
 709                                 memset(pBuf, 0x00, len);
 710                                 memcpy(pBuf, pTemp, len-1);
 711
 712                                 TRIM(pBuf);
 713                                 _VUnescape(pBuf);
 714
 715                                 *pStatus = VCARD_TYPE_NAME_STATUS;
 716
 717                                 c1 = *pVCardRaw;
 718
 719                                 if ((c1 == '\r') || (c1 == '\n')) {
 720                                         pVCardRaw += 1;
 721                                         (*pDLen) += 1;
 722                                 }
 723
 724                                 if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
 725
 726                                         bufferCount = (len * 6 / 8) + 5;
 727
 728                                         if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
 729                                                 VFREE(pBuf);
 730                                                 return NULL;
 731                                         }
 732
 733                                         memset(pTmpBuf, 0x00, bufferCount);
 734                                         num = _VB64Decode(pTmpBuf, pBuf);
 735
 736                                         if (pType != NULL)
 737                                                 pType->numOfBiData = num;
 738
 739                                         VFREE(pBuf);
 740                                         pBuf = pTmpBuf;
 741                                         pTmpBuf = NULL;
 742                                         break;
 743                                 }
 744
 745                                 if (enc & pEncList[2].flag) {
 746
 747                                         int i = 0, j = 0;
 748
 749                                         while (pBuf[i]) {
 750                                                 if (pBuf[i] == '\n' || pBuf[i] == '\r') {
 751                                                         i++;
 752                                                         if (pBuf[i] == '\n' || pBuf[i] == '\r')
 753                                                                 i++;
 754
 755                                                         if (pBuf[j-1] == '=') j--;
 756                                                 } else
 757                                                         pBuf[j++] = pBuf[i++];
 758                                         }
 759                                         pBuf[j] = '\0';
 760
 761                                         _VQPDecode(pBuf);
 762                                         TRIM(pBuf);
 763                                         break;
 764                                 }
 765                                 break;
 766                         }
 767                 }
 768         }
 769         VDATA_TRACE_END
 770         return pBuf;
 771 }
 772
 773
 774 int
 775 VCardGetTypeValue(int index)
 776 {
 777         VDATA_TRACE_BEGINE
 778         VDATA_TRACE("VCardGetTypeValue() enter..\n");
 779         VDATA_TRACE_END
 780         return pTypeList[index].flag;
 781 }
 782
 783 int
 784 VCardGetValValue(int index)
 785 {
 786         VDATA_TRACE_BEGINE
 787         VDATA_TRACE("VCardGetValValue() enter..\n");
 788         VDATA_TRACE_END
 789         return pValueList[index].flag;
 790 }
 791
 792 int
 793 VCardGetEncValue(int index)
 794 {
 795         VDATA_TRACE_BEGINE
 796         VDATA_TRACE("VCardGetEncValue() enter..\n");
 797         VDATA_TRACE_END
 798         return pEncList[index].flag;
 799 }
 800
 801 int
 802 VCardGetCharsetValue(int index)
 803 {
 804         VDATA_TRACE_BEGINE
 805         VDATA_TRACE("VCardGetCharsetValue() enter..\n");
 806         VDATA_TRACE_END
 807         return pCharsetList[index].flag;
 808 }
 809
 810 /*
 811  * vcard_decode() decode the vCard data and returns vObject struct
 812  *
 813  * @param       pVCardRaw            The raw data
 814  * @return      vObject             The result value
 815  */
 816 VTree* vcard_decode(char *pCardRaw)
 817 {
 818         VDATA_TRACE_BEGINE;
 819         char* szValue = NULL;
 820         char* szCardBegin = NULL;
 821         char* pCardRawTmp = NULL;
 822         VTree* pVCard = NULL;
 823         VParam* pTmpParam = NULL;
 824         VObject* pTemp = NULL;
 825
 826         char    c;
 827
 828         int type, param;
 829         int status = VCARD_TYPE_NAME_STATUS;
 830         int done = false;
 831         int valueCount = 0;
 832         int len;
 833         int dLen = 0;
 834         int param_status = false;
 835         int numberedParam = 0;
 836         int enc = 0;
 837         /* int start_status = 0; */
 838         char* temp = NULL;
 839
 840         bool vcard_ended = false;
 841
 842         SysRequireEx(pCardRaw != NULL, NULL);
 843         len = strlen(pCardRaw);
 844         VDATA_TRACE("length of pCardRaw = %d", len);
 845
 846         pCardRaw = _VUnfoldingNoSpecNew(pCardRaw);
 847         if (pCardRaw == NULL)
 848                 return NULL;
 849
 850         pCardRawTmp = pCardRaw;
 851         len = _VManySpace2Space(pCardRaw);
 852
 853         VDATA_TRACE("ret value of _VManySpace2Space = %d", len);
 854
 855         if (!__VIsVcardFile(pCardRaw, CHECK_START)) {
 856                 VFREE(pCardRawTmp);
 857                 VDATA_TRACE_END
 858                 return NULL;
 859         }
 860
 861
 862         while (true && !done) {
 863                 c = *pCardRaw;
 864
 865                 if ((c == '\0') || done)
 866                         break;
 867
 868                 switch (status) {
 869                 case VCARD_TYPE_NAME_STATUS:
 870                         dLen = 0;
 871                         type = __VCardGetTypeName(pCardRaw, &status, &dLen);
 872                         pCardRaw += dLen;
 873
 874                         if (type == -1)
 875                                 break;
 876
 877                         switch (type) {
 878                         case VCARD_TYPE_BEGIN:
 879                                 if (pVCard) {
 880                                         free(pVCard);
 881                                         pVCard = NULL;
 882                                 }
 883
 884                                 if ((pVCard = (VTree*)calloc(1,  sizeof(VTree))) == NULL) {
 885                                         /* start_status = 1; */
 886                                         goto CATCH;
 887                                 }
 888
 889                                 memset(pVCard, 0x00, sizeof(VTree));
 890
 891                                 dLen = 0;
 892                                 szCardBegin = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, NULL);
 893                                 pCardRaw += dLen;
 894                                 VFREE(szCardBegin);
 895
 896                                 pVCard->treeType = VCARD;
 897                                 pVCard->pTop = NULL;
 898                                 pVCard->pCur = NULL;
 899                                 pVCard->pNext = NULL;
 900                                 break;
 901
 902                         case VCARD_TYPE_END:
 903                                 enc = 0;
 904                                 if (strstr(pCardRaw, "VCARD") != NULL) {
 905                                         pCardRaw += dLen;
 906                                         done = true;
 907                                         vcard_ended = true;
 908                                 } else  {
 909                                         status = VCARD_TYPE_NAME_STATUS;
 910                                         pCardRaw += dLen;
 911                                         /*VFREE(etemp); */
 912                                 }
 913                                 break;
 914
 915                         case UNKNOWN_NAME:
 916                                 break;
 917
 918                         default:
 919                                 if (UNKNOWN_NAME == type || type < 0) {
 920                                         status = VCARD_TYPE_NAME_STATUS;
 921                                         break;
 922                                 }
 923
 924                                 if ((pTemp = (VObject*)calloc(1,  sizeof(VObject))) == NULL)
 925                                         goto CATCH;
 926
 927                                 memset(pTemp, 0, sizeof(VObject));
 928                                 pTemp->property = type;
 929
 930                                 if (pVCard->pTop == NULL) {
 931                                         pVCard->pTop = pTemp;
 932                                         pVCard->pCur = pTemp;
 933                                 } else {
 934                                         pVCard->pCur->pSibling = pTemp;
 935                                         pVCard->pCur = pTemp;
 936                                 }
 937
 938                                 break;
 939                         }
 940
 941                         numberedParam = 0;
 942                         param_status = false;
 943                         valueCount = 0;
 944
 945 #ifdef VDATA_GROUPNAME_SUPPORTED
 946                         if (gszGroupName != NULL)
 947                                 pVCard->pCur->pszGroupName = gszGroupName;
 948 #endif
 949                         break;
 950
 951                 case VCARD_PARAM_NAME_STATUS:
 952                 {
 953                         dLen = 0;
 954                         param = __VCardGetParamName(pCardRaw, &status, &dLen);
 955                         pCardRaw += dLen;
 956
 957                         if (param_status != true) {
 958
 959                                 if ((pTmpParam = (VParam*)calloc(1,  sizeof(VParam))) == NULL)
 960                                                 goto CATCH;
 961
 962                                 param_status = true;
 963                                 pVCard->pCur->pParam = pTmpParam;
 964                                 memset(pTmpParam, 0x00, sizeof(VParam));
 965                                 VDATA_TRACE("pTmpParam : %p", pTmpParam);
 966                         } else {
 967                                 if ((pTmpParam->pNext = (VParam*)calloc(1,  sizeof(VParam))) == NULL)
 968                                         goto CATCH;
 969
 970                                 pTmpParam = pTmpParam->pNext;
 971                                 memset(pTmpParam, 0x00, sizeof(VParam));
 972                                 VDATA_TRACE("pTmpParam : %p", pTmpParam);
 973                         }
 974
 975                         pTmpParam->parameter = param;
 976                         break;
 977                 }
 978                 case VCARD_PARAM_VALUE_STATUS:
 979                         dLen = 0;
 980                         numberedParam = 0;
 981                         switch (pTmpParam->parameter) {
 982                         case VCARD_PARAM_TYPE:
 983                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 984                                 numberedParam |= __VCardGetValue(szValue, pTypeList, VCARD_TYPE_PARAM_NUM);
 985                                 break;
 986                         case VCARD_PARAM_VALUE:
 987                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 988                                 numberedParam |= __VCardGetValue(szValue, pValueList, VCARD_VALUE_PARAM_NUM);
 989                                 break;
 990                         case VCARD_PARAM_ENCODING:
 991                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 992                                 numberedParam |= __VCardGetValue(szValue, pEncList, VCARD_ENCODE_PARAM_NUM);
 993                                 enc = numberedParam;
 994                                 break;
 995                         case VCARD_PARAM_CHARSET:
 996                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 997                                 numberedParam |= __VCardGetValue(szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM);
 998                                 break;
 999                         case VCARD_PARAM_CONTEXT:
1000                         case VCARD_PARAM_LANGUAGE:
1001                                 /* prevent 7605 08.03.13 */
1002                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1003                                 numberedParam = 0;
1004                                 break;
1005                         default:
1006                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1007
1008                                 SET_PARAM_VALUE(numberedParam, szValue, pTypeList, VCARD_TYPE_PARAM_NUM, pTmpParam, VCARD_PARAM_TYPE, enc);
1009                                 SET_PARAM_VALUE(numberedParam, szValue, pValueList, VCARD_VALUE_PARAM_NUM, pTmpParam, VCARD_PARAM_VALUE, enc);
1010                                 SET_PARAM_VALUE(numberedParam, szValue, pEncList, VCARD_ENCODE_PARAM_NUM, pTmpParam, VCARD_PARAM_ENCODING, enc);
1011                                 SET_PARAM_VALUE(numberedParam, szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM, pTmpParam, VCARD_PARAM_CHARSET, enc);
1012
1013                                 numberedParam = 0;
1014                                 pCardRaw += dLen;
1015                                 dLen = 0;
1016
1017                                 break;
1018                         }
1019
1020                         VDATA_TRACE("%d, %s, %p", numberedParam, szValue, pTmpParam);
1021                         pTmpParam->paramValue = numberedParam;
1022                         pTmpParam->pNext = NULL;
1023                         VFREE(szValue);
1024                         pCardRaw += dLen;
1025                         break;
1026                 case VCARD_TYPE_VALUE_STATUS:
1027                         dLen = 0;
1028                         temp = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, pVCard->pCur);
1029
1030                         if (valueCount < VDATA_VALUE_COUNT_MAX) {
1031                                 pVCard->pCur->pszValue[valueCount] = temp;
1032                                 valueCount++;
1033                                 pVCard->pCur->valueCount = valueCount;
1034                         } else
1035                                 VFREE(temp);
1036
1037                         pCardRaw += dLen;
1038                         break;
1039                 }
1040         }
1041
1042         VFREE(pCardRawTmp);
1043
1044         if (pVCard->pTop == NULL)
1045                 goto CATCH;
1046
1047         if (!vcard_ended)
1048                 goto CATCH1;
1049
1050         VDATA_TRACE_END
1051         return pVCard;
1052
1053 CATCH:
1054         VFREE(pTemp);
1055 CATCH1:
1056         VFREE(pCardRawTmp);
1057         vcard_free_vtree_memory(pVCard);
1058         VDATA_TRACE_END
1059         return NULL;
1060 }
1061
1062 /*
1063  * vcard_encode() compares the string and vCard type, parameter value.
1064  *
1065  * @param       pVCardRaw            Data which will be encoded
1066  * @return      char *              Encoded result
1067  */
1068 char* vcard_encode(VTree *pVCardRaw)
1069 {
1070         VDATA_TRACE_BEGINE
1071         char*           pVCardRes = NULL;
1072         VObject *       pTmpObj =  NULL;
1073         char*           pTemp = NULL;
1074         int                     len;
1075         int                     total = 0;
1076         int                     cnt = 0;
1077         int                     lenTypeList = 0;
1078
1079         LENGTH_TYPE_LIST(pszCardTypeList, lenTypeList);
1080
1081         SysRequireEx(pVCardRaw != NULL, NULL);
1082         SysRequireEx(pVCardRaw->pTop != NULL, NULL);
1083         SysRequireEx(pVCardRaw->pTop->property >= 0, NULL);
1084         SysRequireEx(pVCardRaw->pTop->property < lenTypeList, NULL);
1085         SysRequireEx(pVCardRaw->treeType == VCARD, NULL);
1086         SysRequireEx(pVCardRaw->pTop->valueCount > 0, NULL);
1087
1088         /* VDATA_TRACE("START %d %d", pVCardRaw->pTop->property, lenTypeList); */
1089
1090         for (; cnt < pVCardRaw->pTop->valueCount; cnt++) {
1091
1092                 if (pVCardRaw->pTop->pszValue[cnt] == NULL)  {
1093                         VDATA_TRACE("pVCardRaw->pTop->valueCount : %d", pVCardRaw->pTop->valueCount);
1094                         VDATA_TRACE("pVCardRaw->pTop->pszValue[%d] : %s", cnt, pVCardRaw->pTop->pszValue[cnt]);
1095                         VDATA_TRACE_END
1096                         return NULL;
1097                 }
1098         }
1099         total += sizeof(char) * (14 + 14);
1100         if ((pVCardRes = (char *)calloc(1, total)) == NULL) {
1101                 VDATA_TRACE("vcard_encode:calloc failed\n");
1102                 VDATA_TRACE_END
1103                 return NULL;
1104         }
1105
1106         memcpy(pVCardRes, "BEGIN:VCARD\r\n", 14);
1107         g_strlcat(pVCardRes, "VERSION:2.1\r\n", total - strlen(pVCardRes));
1108
1109         pTmpObj = pVCardRaw->pTop;
1110
1111         while (true) {
1112                 if (pTmpObj == NULL)
1113                         break;
1114
1115                 if ((pTemp = __VCardTypeEncode(pTmpObj, pszCardTypeList[pTmpObj->property])) != NULL) {
1116                         len = strlen(pTemp);
1117                         total += len + sizeof(char) * 10;
1118                         if ((pVCardRes = (char*)realloc(pVCardRes, total)) == NULL) {
1119                                 VDATA_TRACE("vcard_encode():realloc failed\n");
1120                                 VFREE(pTemp);
1121                                 pTemp = NULL;
1122                                 VDATA_TRACE_END
1123                                 return NULL;
1124                         }
1125
1126                         if (strncmp(pTemp, "VERSION", strlen("VERSION")) != 0)
1127                                 g_strlcat(pVCardRes, pTemp, total - strlen(pVCardRes));
1128
1129                         VDATA_TRACE("pTemp : %s", pTemp);
1130
1131                         VFREE(pTemp);
1132                         pTemp = NULL;
1133                 }
1134
1135                 if (pTmpObj->pSibling != NULL)
1136                         pTmpObj = pTmpObj->pSibling;
1137                 else
1138                         break;
1139         }
1140
1141         total += sizeof(char) * 12;
1142         if ((pVCardRes = (char *)realloc(pVCardRes, total)) == NULL) {
1143                 VDATA_TRACE("vcard_encode:realloc failed\n");
1144                 VDATA_TRACE_END
1145                 return NULL;
1146         }
1147         g_strlcat(pVCardRes, "END:VCARD\r\n", total - strlen(pVCardRes));
1148         VDATA_TRACE_END
1149         return pVCardRes;
1150 }
1151
1152
1153 /*
1154  * VIsVcardFile() verify VCard file.
1155  *
1156  * @param       pVCardRaw           Data which will be encoded
1157  * @return      int                 result (true or false)
1158  */
1159 int
1160 __VIsVcardFile(char *pCardRaw, int mode)
1161 {
1162         int i = 0;
1163         bool rtnValue = true;
1164         char *pszVcardBegin = "BEGIN:VCARD";
1165
1166         switch (mode) {
1167         case CHECK_START:
1168                 for (i = 0; i < 11; i++)
1169                         if (*pszVcardBegin++ != *pCardRaw++)
1170                                 rtnValue = false;
1171                 break;
1172
1173         default:
1174                 rtnValue = false;
1175         }
1176         VDATA_TRACE_END
1177         return rtnValue;
1178 }
1179
1180
1181 /*
1182  * vCardTypeEncoder() compares the string and vCard type, parameter value.
1183  *
1184  * @param               typeObj                         Data which will be encoded
1185  * @param               type                            Name of the type
1186  * @return      char *              Encoded result
1187  */
1188 char*
1189 __VCardTypeEncode(VObject *pTypeObj, char *pType)
1190 {
1191         VDATA_TRACE_BEGINE
1192         int                     len;
1193         char*           pTemp = NULL;
1194         char*           szTypeValue = NULL;
1195         int                     i;
1196         int                     enc = 0;
1197         char*           pEncode = NULL;
1198         char*           pRes = NULL;
1199         int                     total = 0;
1200         int                     biLen = 0;
1201
1202         len = strlen(pType);
1203         biLen = pTypeObj->numOfBiData;
1204
1205 #ifdef VDATA_GROUPNAME_SUPPORTED
1206         if (pTypeObj->pszGroupName != NULL)
1207                 len += strlen(pTypeObj->pszGroupName) + 1;
1208 #endif /* VDATA_GROUPNAME_SUPPORTED */
1209
1210         if ((szTypeValue = (char *)calloc(1,  total += (len+1))) == NULL) {
1211                 VDATA_TRACE("__VCardTypeEncode():calloc failed\n");
1212                 VDATA_TRACE_END
1213                 return NULL;
1214         }
1215         memset(szTypeValue, '\0', (len+1));
1216 #ifdef VDATA_GROUPNAME_SUPPORTED
1217         if (pTypeObj->pszGroupName != NULL) {
1218                 g_strlcat(szTypeValue, pTypeObj->pszGroupName, total - strlen(szTypeValue));
1219                 g_strlcat(szTypeValue, ".", total - strlen(szTypeValue));
1220         }
1221 #endif /* VDATA_GROUPNAME_SUPPORTED */
1222         g_strlcat(szTypeValue, pType, total - strlen(szTypeValue));
1223
1224         pTemp = __VCardParamEncode(pTypeObj, &enc);
1225         if (pTemp != NULL) {
1226                 len = strlen(pTemp);
1227                 if ((szTypeValue = (char *)realloc(szTypeValue, (total += len))) == NULL) {
1228                         VDATA_TRACE("__VCardTypeEncode():realloc failed\n");
1229                         VFREE(pTemp);
1230                         pTemp = NULL
1231                         VDATA_TRACE_END;
1232                         return NULL;
1233                 }
1234                 g_strlcat(szTypeValue, pTemp, total - strlen(szTypeValue));
1235                 VFREE(pTemp);
1236                 pTemp = NULL;
1237         }
1238
1239         if ((szTypeValue = (char *)realloc(szTypeValue, (total += 2))) == NULL) {
1240                 VDATA_TRACE_END
1241                 return NULL;
1242         }
1243
1244         g_strlcat(szTypeValue, ":", total - strlen(szTypeValue));
1245
1246         len = 0;
1247
1248         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1249                 for (i = 0; i < pTypeObj->valueCount; i++) {
1250
1251                         if (pTypeObj->pszValue[i] != NULL)
1252                                 len += strlen(pTypeObj->pszValue[i]);
1253                 }
1254         } else {
1255                 len += biLen;
1256         }
1257
1258         for (i = 0; i < pTypeObj->valueCount; i++) {
1259
1260                 if (i == 0) {
1261                         if ((pEncode = (char *)calloc(1,  len+20)) == NULL) {
1262                                 VFREE(szTypeValue);
1263                                 VDATA_TRACE_END
1264                                 return NULL;
1265                         }
1266
1267                         memset(pEncode, '\0', len+20);
1268
1269                         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1270                                 g_strlcat(pEncode, pTypeObj->pszValue[i], len+20 - strlen(pEncode));
1271                                 _VEscape(pEncode);
1272                         } else {
1273                                 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1274                         }
1275                 } else {
1276                         char    buf[1000];
1277                         strncpy(buf, pTypeObj->pszValue[i], 999);
1278                         _VEscape(buf);
1279                         g_strlcat(pEncode, ";", len+20 - strlen(pEncode));
1280                         g_strlcat(pEncode, buf, len+20 - strlen(pEncode));
1281                 }
1282         }
1283
1284         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1285                 if (pEncode) {
1286                         g_strlcat(pEncode, "\0\0", len+20 - strlen(pEncode));
1287                         len = strlen(pEncode);
1288                 }
1289         } else {
1290                 len = biLen;
1291         }
1292
1293         if (enc & pEncList[2].flag) {
1294                 if ((pRes = (char *)calloc(1, len * 6 + 10)) == NULL) {
1295                         VFREE(pEncode);
1296                         VFREE(szTypeValue);
1297                         VDATA_TRACE_END
1298                         return NULL;
1299                 }
1300                 if (pEncode)
1301                         _VQPEncode(pRes, pEncode);
1302                 VFREE(pEncode);
1303         } else if (enc & pEncList[1].flag) {
1304                 if ((pRes = (char *)calloc(1, (len * 8 / 6) + 4)) == NULL) {
1305                         VFREE(pEncode);
1306                         VFREE(szTypeValue);
1307                         VDATA_TRACE_END
1308                         return NULL;
1309                 }
1310
1311                 memset(pRes, '\0', ((len * 8 / 6) + 4));
1312                 _VB64Encode(pRes, pEncode, biLen);
1313                 VFREE(pEncode);
1314         } else {
1315                 if ((pRes = (char *)calloc(1, len+30)) == NULL) {
1316                         VFREE(pEncode);
1317                         VFREE(szTypeValue);
1318                         VDATA_TRACE_END
1319                         return NULL;
1320                 }
1321                 memset(pRes, '\0', (len + 30));
1322                 if (pEncode) {
1323                         memcpy(pRes, pEncode, len);
1324                         VFREE(pEncode);
1325                 }
1326         }
1327
1328         if ((pRes = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL) {
1329                 VFREE(pEncode);
1330                 VFREE(szTypeValue);
1331                 VDATA_TRACE_END
1332                 return NULL;
1333         }
1334         g_strlcat(pRes, "\r\n", 2);
1335
1336         len = strlen(pRes);
1337
1338         if ((szTypeValue = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1339                 VFREE(pEncode);
1340                 VFREE(pRes);
1341                 VDATA_TRACE_END
1342                 return NULL;
1343         }
1344
1345         g_strlcat(szTypeValue, pRes, total - strlen(szTypeValue));
1346
1347         if (strcmp(pType, pszCardTypeList[19]) != 0) {
1348                 _VRLSpace(szTypeValue);
1349                 _VRTSpace(szTypeValue);
1350         }
1351
1352         VFREE(pRes);
1353         VDATA_TRACE_END
1354         return szTypeValue;
1355 }
1356
1357 /**
1358  * __VCardParamEncode() Parameter Encoding.
1359  *
1360  * @param               pTypeObj                Data which will be encoded
1361  * @param               pEnc                            Name of the type
1362  */
1363 char *
1364 __VCardParamEncode(VObject* pTypeObj, int* pEnc)
1365 {
1366         VDATA_TRACE_BEGINE
1367         int i = 0;
1368         int len = 0;
1369         int sNum = 0;
1370         int shift = 0;
1371         bool bSupported;
1372         char* szParam = NULL;
1373         VParam* pTemp = NULL;
1374         ValueObj*       pList = NULL;
1375
1376         /** Paramter initialize. */
1377         pTemp = pTypeObj->pParam;
1378
1379         /** Momory Allocation for parameter string. */
1380         if (pTemp != NULL) {
1381                 if ((szParam = (char*)calloc(1, len += 2)) == NULL) {
1382                         VDATA_TRACE_END
1383                         return NULL;
1384                 }
1385                 memset(szParam, 0x00, 2);
1386         }
1387
1388         /** appending pamaters. */
1389         while (true) {
1390
1391                 if (pTemp == NULL) break;
1392
1393                 bSupported = false;
1394
1395                 /** Expand szParam string. For appending.*/
1396                 if ((szParam = (char *)realloc(szParam, len += 15)) == NULL) {
1397                         VDATA_TRACE_END
1398                         return NULL;
1399                 }
1400
1401                 /** appending paramter name. */
1402                 g_strlcat(szParam, ";", len - strlen(szParam));
1403                 if (pTemp->parameter != VCARD_PARAM_TYPE) {
1404                         g_strlcat(szParam, pszCardParamList[pTemp->parameter], len - strlen(szParam));
1405                         g_strlcat(szParam, "=", len - strlen(szParam));
1406                 }
1407
1408                 /** Set Parameter Value name. */
1409                 switch (pTemp->parameter) {
1410                 case VCARD_PARAM_ENCODING:
1411                         *pEnc = pTemp->paramValue;
1412                         shift = VCARD_ENCODE_PARAM_NUM;
1413                         pList = pEncList; bSupported = true;
1414                         break;
1415                 case VCARD_PARAM_TYPE:
1416                         shift = VCARD_TYPE_PARAM_NUM;
1417                         pList = pTypeList; bSupported = true;
1418                         break;
1419                 case VCARD_PARAM_VALUE:
1420                         shift = VCARD_VALUE_PARAM_NUM;
1421                         pList = pValueList; bSupported = true;
1422                         break;
1423                 case VCARD_PARAM_CHARSET:
1424                         shift = VCARD_CHARSET_PARAM_NUM;
1425                         pList = pCharsetList; bSupported = true;
1426                         break;
1427                 default:
1428                         if ((szParam = (char*)realloc(szParam, 5)) == NULL) {
1429                                 VDATA_TRACE_END
1430                                 return NULL;
1431                         }
1432                         g_strlcat(szParam, "NONE", 5 - strlen(szParam));
1433                 }
1434
1435                 /** exchage parameter value's to string.*/
1436                 if (bSupported == true) {
1437
1438                         for (i = 0, sNum = 0x00000001; i < shift; i++) {
1439
1440                                 if (pTemp->paramValue & sNum) {
1441                                         if ((szParam = (char *)realloc(szParam, (len += (strlen(pList[i].szName) + 2)))) == NULL) {
1442                                                 VDATA_TRACE_END
1443                                                 return NULL;
1444                                         }
1445
1446                                         g_strlcat(szParam, pList[i].szName, len - strlen(szParam));
1447                                         g_strlcat(szParam, "; ", len - strlen(szParam));
1448                                 }
1449
1450                                 sNum <<= 1;
1451                         }
1452                 }
1453
1454                 /** remove semicolon from tail. */
1455                 for (i = strlen(szParam); i > 0 ; i--) {
1456
1457                         if (szParam[i] == ' ' && szParam[i-1] == ';') {
1458                                 szParam[i-1] = '\0';
1459                                 break;
1460                         }
1461                 }
1462
1463                 if (pTemp->pNext != NULL)
1464                         pTemp = pTemp->pNext;
1465                 else
1466                         break;
1467         }
1468         VDATA_TRACE_END
1469         return szParam;
1470 }
1471
1472 bool vcard_free_vtree_memory(VTree * pTree)
1473 {
1474         VDATA_TRACE_BEGINE
1475         if (pTree == NULL) {
1476                 VDATA_TRACE_END
1477                 return false;
1478         }
1479         VDATA_TRACE_END
1480         return __VCardFreeVTreeMemory(pTree);
1481 }
1482