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
 504 #ifdef VDATA_GROUPNAME_SUPPORTED
 505                         if (pCurObj->pszGroupName)
 506                                 VFREE(pCurObj->pszGroupName);
 507 #endif
 508
 509                         if (pCurObj->pParam) {
 510
 511                                 pCurParam = pCurObj->pParam;
 512
 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);
 525                                         }
 526                                         VFREE(pCurParam);
 527                                         pCurParam = pNextParam;
 528                                 }
 529                         }
 530
 531                         VFREE(pCurObj);
 532                         pCurObj = pNextObj;
 533                 }
 534
 535                 VFREE(pCurTree);
 536                 pCurTree = pNextTree;
 537         }
 538
 539         VDATA_TRACE("exit vcard_free_vtree_memory");
 540         VDATA_TRACE_END
 541         return true;
 542 }
 543
 544 /**
 545  * __VCardGetParamVal() fine the param value and returns value.
 546  *
 547  * @param               pVCardRaw       The raw data
 548  * @param               pStatus         Decoder status
 549  * @param               pDLen           retrived length
 550  *
 551  * @return      buffer          The result value
 552  */
 553 char*
 554 __VCardGetParamVal(char* pVCardRaw, int* pStatus, int* pDLen)
 555 {
 556         VDATA_TRACE_BEGINE
 557         int len = 0;
 558         char    c;
 559         char* pBuf = NULL;
 560         char* pTemp = pVCardRaw;
 561
 562         SysRequireEx(pVCardRaw, NULL);
 563
 564         while (true) {
 565                 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
 566                 len++;
 567                 switch (c) {
 568                         case VTYPE_TOKEN_SEMICOLON:
 569                                 *pStatus = VCARD_PARAM_NAME_STATUS;
 570                                 break;
 571                         case VTYPE_TOKEN_COLON:
 572                                 *pStatus = VCARD_TYPE_VALUE_STATUS;
 573                                 break;
 574                         case VTYPE_TOKEN_COMMA:
 575                                 *pStatus = VCARD_PARAM_VALUE_STATUS;
 576                                 break;
 577                 }
 578                 if (c == VTYPE_TOKEN_SEMICOLON
 579                                 || c == VTYPE_TOKEN_COLON
 580                                 || c == VTYPE_TOKEN_COMMA
 581                                 || c == 0x00)
 582                         break;
 583         }
 584
 585         /* if (len < 1)
 586                 return NULL;
 587         */
 588
 589         pBuf = (char *)calloc(1, len);
 590         if (pBuf  == NULL)
 591                 return NULL;
 592
 593         memset(pBuf, 0x00, len);
 594         memcpy(pBuf, pTemp, len-1);
 595         TRIM(pBuf);
 596         VDATA_TRACE_END
 597         return pBuf;
 598 }
 599
 600
 601 /**
 602  * __VCardGetTypeVal() fine the type value and returns value.
 603  *
 604  * @param       pVCardRaw       The raw data
 605  * @param               status                  Decoder status
 606  * @return      buffer          The result value
 607  */
 608 char*
 609 __VCardGetTypeVal(char* pVCardRaw, int* pStatus, int* pDLen, int enc, VObject* pType)
 610 {
 611         VDATA_TRACE_BEGINE
 612         int num = 0;
 613         int len = 0;
 614         int bufferCount = 0;
 615
 616         bool bEscape = false;
 617
 618         char    c, c1, c2;
 619         char* pBuf = NULL;
 620         char* pTemp = pVCardRaw;
 621         char* pTmpBuf = NULL;
 622         int Status = 0;
 623         int Len = 0;
 624
 625         SysRequireEx(pVCardRaw, NULL);
 626
 627         while (true) {
 628                 GO_NEXT_CHAR(c, pVCardRaw, pDLen);
 629
 630                 if (c == 0x00) break;
 631
 632                 len++;
 633
 634                 /** This case means that there are more type's value. */
 635                 if (c == VTYPE_TOKEN_SEMICOLON && bEscape == false) {
 636
 637                         if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
 638
 639                         memset(pBuf, 0x00, len);
 640                         memcpy(pBuf, pTemp, len-1);
 641
 642                         TRIM(pBuf);
 643                         _VUnescape(pBuf);
 644
 645                         *pStatus = VCARD_TYPE_VALUE_STATUS;
 646
 647                         /** Base 64 Decoding */
 648                         if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
 649
 650                                 bufferCount = (len * 6 / 8) + 2;
 651
 652                                 if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
 653                                         VFREE(pBuf);
 654                                         return NULL;
 655                                 }
 656
 657                                 memset(pTmpBuf, 0x00, bufferCount);
 658                                 num = _VB64Decode(pTmpBuf, pBuf);
 659
 660                                 if (pType != NULL) pType->numOfBiData = num;
 661
 662                                 VFREE(pBuf);
 663                                 pBuf = pTmpBuf;
 664                                 pTmpBuf = NULL;
 665                                 break;
 666                         }
 667
 668                         /** Quoted Printable Decoding */
 669                         if (enc & pEncList[2].flag) {
 670
 671                                 int i = 0, j = 0;
 672
 673                                 while (pBuf[i]) {
 674                                         if (pBuf[i] == '\n' || pBuf[i] == '\r') {
 675                                                 i++;
 676                                                 if (pBuf[i] == '\n' || pBuf[i] == '\r')
 677                                                         i++;
 678
 679                                                 if (pBuf[j-1] == '=') j--;
 680                                         } else
 681                                                 pBuf[j++] = pBuf[i++];
 682                                 }
 683                                 pBuf[j] = '\0';
 684
 685                                 _VQPDecode(pBuf);
 686                                 TRIM(pBuf);
 687                                 break;
 688                         }
 689                         break;
 690                 }
 691
 692                 if (c == '\\')
 693                         bEscape = true;
 694                 else if (bEscape == true && c != VTYPE_TOKEN_SEMICOLON)
 695                         bEscape = false;
 696                 else if ((c == '\r') || (c == '\n')) {
 697                         c2 = *(pVCardRaw-2);
 698
 699                         if (c2 == '=' && (enc & pEncList[2].flag)) {
 700                                 c1 = *pVCardRaw;
 701                                 if ((c1 == '\r') || (c1 == '\n')) {
 702                                         pVCardRaw += 1;
 703                                         (*pDLen) += 1;
 704                                         len++;
 705                                 }
 706                         } else if (__VCardGetTypeName(pVCardRaw, &Status, &Len) != UNKNOWN_NAME) {
 707                                 --len;
 708                                 if ((pBuf = (char *)calloc(1, len)) == NULL) return NULL;
 709
 710                                 memset(pBuf, 0x00, len);
 711                                 memcpy(pBuf, pTemp, len-1);
 712
 713                                 TRIM(pBuf);
 714                                 _VUnescape(pBuf);
 715
 716                                 *pStatus = VCARD_TYPE_NAME_STATUS;
 717
 718                                 c1 = *pVCardRaw;
 719
 720                                 if ((c1 == '\r') || (c1 == '\n')) {
 721                                         pVCardRaw += 1;
 722                                         (*pDLen) += 1;
 723                                 }
 724
 725                                 if ((enc & pEncList[1].flag) || (enc & pEncList[0].flag)) {
 726
 727                                         bufferCount = (len * 6 / 8) + 5;
 728
 729                                         if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
 730                                                 VFREE(pBuf);
 731                                                 return NULL;
 732                                         }
 733
 734                                         memset(pTmpBuf, 0x00, bufferCount);
 735                                         num = _VB64Decode(pTmpBuf, pBuf);
 736
 737                                         if (pType != NULL)
 738                                                 pType->numOfBiData = num;
 739
 740                                         VFREE(pBuf);
 741                                         pBuf = pTmpBuf;
 742                                         pTmpBuf = NULL;
 743                                         break;
 744                                 }
 745
 746                                 if (enc & pEncList[2].flag) {
 747
 748                                         int i = 0, j = 0;
 749
 750                                         while (pBuf[i]) {
 751                                                 if (pBuf[i] == '\n' || pBuf[i] == '\r') {
 752                                                         i++;
 753                                                         if (pBuf[i] == '\n' || pBuf[i] == '\r')
 754                                                                 i++;
 755
 756                                                         if (pBuf[j-1] == '=') j--;
 757                                                 } else
 758                                                         pBuf[j++] = pBuf[i++];
 759                                         }
 760                                         pBuf[j] = '\0';
 761
 762                                         _VQPDecode(pBuf);
 763                                         TRIM(pBuf);
 764                                         break;
 765                                 }
 766                                 break;
 767                         }
 768                 }
 769         }
 770         VDATA_TRACE_END
 771         return pBuf;
 772 }
 773
 774
 775 int
 776 VCardGetTypeValue(int index)
 777 {
 778         VDATA_TRACE_BEGINE
 779         VDATA_TRACE("VCardGetTypeValue() enter..\n");
 780         VDATA_TRACE_END
 781         return pTypeList[index].flag;
 782 }
 783
 784 int
 785 VCardGetValValue(int index)
 786 {
 787         VDATA_TRACE_BEGINE
 788         VDATA_TRACE("VCardGetValValue() enter..\n");
 789         VDATA_TRACE_END
 790         return pValueList[index].flag;
 791 }
 792
 793 int
 794 VCardGetEncValue(int index)
 795 {
 796         VDATA_TRACE_BEGINE
 797         VDATA_TRACE("VCardGetEncValue() enter..\n");
 798         VDATA_TRACE_END
 799         return pEncList[index].flag;
 800 }
 801
 802 int
 803 VCardGetCharsetValue(int index)
 804 {
 805         VDATA_TRACE_BEGINE
 806         VDATA_TRACE("VCardGetCharsetValue() enter..\n");
 807         VDATA_TRACE_END
 808         return pCharsetList[index].flag;
 809 }
 810
 811 /*
 812  * vcard_decode() decode the vCard data and returns vObject struct
 813  *
 814  * @param       pVCardRaw            The raw data
 815  * @return      vObject             The result value
 816  */
 817 VTree* vcard_decode(char *pCardRaw)
 818 {
 819         VDATA_TRACE_BEGINE;
 820         char* szValue = NULL;
 821         char* szCardBegin = NULL;
 822         char* pCardRawTmp = NULL;
 823         VTree* pVCard = NULL;
 824         VParam* pTmpParam = NULL;
 825         VObject* pTemp = NULL;
 826
 827         char    c;
 828
 829         int type, param;
 830         int status = VCARD_TYPE_NAME_STATUS;
 831         int done = false;
 832         int valueCount = 0;
 833         int len;
 834         int dLen = 0;
 835         int param_status = false;
 836         int numberedParam = 0;
 837         int enc = 0;
 838         //int start_status = 0;
 839         char* temp = NULL;
 840
 841         bool vcard_ended = false;
 842
 843         SysRequireEx(pCardRaw != NULL, NULL);
 844         len = strlen(pCardRaw);
 845         VDATA_TRACE("length of pCardRaw = %d", len);
 846
 847         pCardRaw = _VUnfoldingNoSpecNew(pCardRaw);
 848         if (pCardRaw == NULL) {
 849                 return NULL;
 850         }
 851         pCardRawTmp = pCardRaw;
 852         len = _VManySpace2Space(pCardRaw);
 853
 854         VDATA_TRACE("ret value of _VManySpace2Space = %d", len);
 855
 856         if (!__VIsVcardFile(pCardRaw, CHECK_START)) {
 857                 VFREE(pCardRawTmp);
 858                 VDATA_TRACE_END
 859                 return NULL;
 860         }
 861
 862
 863         while (true && !done) {
 864                 c = *pCardRaw;
 865
 866                 if ((c == '\0') || done)
 867                         break;
 868
 869                 switch (status) {
 870                         case VCARD_TYPE_NAME_STATUS:
 871                                 dLen = 0;
 872                                 type = __VCardGetTypeName(pCardRaw, &status, &dLen);
 873                                 pCardRaw += dLen;
 874
 875                                 if (type == -1)
 876                                         break;
 877
 878                                 switch (type) {
 879                                         case VCARD_TYPE_BEGIN:
 880                                                 if (pVCard) {
 881                                                         free(pVCard);
 882                                                         pVCard = NULL;
 883                                                 }
 884
 885                                                 if ((pVCard = (VTree*)calloc(1,  sizeof(VTree))) == NULL) {
 886                                                         //start_status = 1;
 887                                                         goto CATCH;
 888                                                 }
 889
 890                                                 memset(pVCard, 0x00, sizeof(VTree));
 891
 892                                                 dLen = 0;
 893                                                 szCardBegin = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, NULL);
 894                                                 pCardRaw += dLen;
 895                                                 VFREE(szCardBegin);
 896
 897                                                 pVCard->treeType = VCARD;
 898                                                 pVCard->pTop = NULL;
 899                                                 pVCard->pCur = NULL;
 900                                                 pVCard->pNext = NULL;
 901                                                 break;
 902
 903                                         case VCARD_TYPE_END:
 904                                                 enc = 0;
 905                                                 if (strstr(pCardRaw, "VCARD") != NULL) {
 906                                                         pCardRaw += dLen;
 907                                                         done = true;
 908                                                         vcard_ended = true;
 909                                                 } else  {
 910                                                         status = VCARD_TYPE_NAME_STATUS;
 911                                                         pCardRaw += dLen;
 912                                                         /*VFREE(etemp); */
 913                                                 }
 914                                                 break;
 915
 916                                         case UNKNOWN_NAME:
 917                                                 break;
 918
 919                                         default:
 920                                                 if (UNKNOWN_NAME == type || type < 0) {
 921                                                         status = VCARD_TYPE_NAME_STATUS;
 922                                                         break;
 923                                                 }
 924
 925                                                 if ((pTemp = (VObject*)calloc(1,  sizeof(VObject))) == NULL) {
 926                                                         goto CATCH;
 927                                                 }
 928
 929                                                 memset(pTemp, 0, sizeof(VObject));
 930                                                 pTemp->property = type;
 931
 932                                                 if (pVCard->pTop == NULL) {
 933                                                         pVCard->pTop = pTemp;
 934                                                         pVCard->pCur = pTemp;
 935                                                 } else {
 936                                                         pVCard->pCur->pSibling = pTemp;
 937                                                         pVCard->pCur = pTemp;
 938                                                 }
 939
 940                                                 break;
 941                                 }
 942
 943                                 numberedParam = 0;
 944                                 param_status = false;
 945                                 valueCount = 0;
 946
 947 #ifdef VDATA_GROUPNAME_SUPPORTED
 948                                 if (gszGroupName != NULL)
 949                                         pVCard->pCur->pszGroupName = gszGroupName;
 950 #endif
 951                                 break;
 952
 953                         case VCARD_PARAM_NAME_STATUS:
 954                         {
 955                                 dLen = 0;
 956                                 param = __VCardGetParamName(pCardRaw, &status, &dLen);
 957                                 pCardRaw += dLen;
 958
 959                                 if (param_status != true) {
 960
 961                                         if ((pTmpParam = (VParam*)calloc(1,  sizeof(VParam))) == NULL)
 962                                                         goto CATCH;
 963
 964                                         param_status = true;
 965                                         pVCard->pCur->pParam = pTmpParam;
 966                                         memset(pTmpParam, 0x00, sizeof(VParam));
 967                                         VDATA_TRACE("pTmpParam : %p", pTmpParam);
 968                                 } else {
 969                                         if ((pTmpParam->pNext = (VParam*)calloc(1,  sizeof(VParam))) == NULL)
 970                                                         goto CATCH;
 971
 972                                         pTmpParam = pTmpParam->pNext;
 973                                         memset(pTmpParam, 0x00, sizeof(VParam));
 974                                         VDATA_TRACE("pTmpParam : %p", pTmpParam);
 975                                 }
 976
 977                                 pTmpParam->parameter = param;
 978                                 break;
 979                         }
 980                         case VCARD_PARAM_VALUE_STATUS:
 981                                 dLen = 0;
 982                                 numberedParam = 0;
 983                                 switch (pTmpParam->parameter) {
 984                                         case VCARD_PARAM_TYPE:
 985                                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 986                                                 numberedParam |= __VCardGetValue(szValue, pTypeList, VCARD_TYPE_PARAM_NUM);
 987                                                 break;
 988                                         case VCARD_PARAM_VALUE:
 989                                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 990                                                 numberedParam |= __VCardGetValue(szValue, pValueList, VCARD_VALUE_PARAM_NUM);
 991                                                 break;
 992                                         case VCARD_PARAM_ENCODING:
 993                                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 994                                                 numberedParam |= __VCardGetValue(szValue, pEncList, VCARD_ENCODE_PARAM_NUM);
 995                                                 enc = numberedParam;
 996                                                 break;
 997                                         case VCARD_PARAM_CHARSET:
 998                                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 999                                                 numberedParam |= __VCardGetValue(szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM);
1000                                                 break;
1001                                         case VCARD_PARAM_CONTEXT:
1002                                         case VCARD_PARAM_LANGUAGE:
1003                                                 // prevent 7605 08.03.13
1004                                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1005                                                 numberedParam = 0;
1006                                                 break;
1007                                         default:
1008                                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1009
1010                                                 SET_PARAM_VALUE(numberedParam, szValue, pTypeList, VCARD_TYPE_PARAM_NUM, pTmpParam, VCARD_PARAM_TYPE, enc);
1011                                                 SET_PARAM_VALUE(numberedParam, szValue, pValueList, VCARD_VALUE_PARAM_NUM, pTmpParam, VCARD_PARAM_VALUE, enc);
1012                                                 SET_PARAM_VALUE(numberedParam, szValue, pEncList, VCARD_ENCODE_PARAM_NUM, pTmpParam, VCARD_PARAM_ENCODING, enc);
1013                                                 SET_PARAM_VALUE(numberedParam, szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM, pTmpParam, VCARD_PARAM_CHARSET, enc);
1014
1015                                                 numberedParam = 0;
1016                                                 pCardRaw += dLen;
1017                                                 dLen = 0;
1018
1019                                                 break;
1020                                 }
1021
1022                                 VDATA_TRACE("%d, %s, %p", numberedParam, szValue, pTmpParam);
1023                                 pTmpParam->paramValue = numberedParam;
1024                                 pTmpParam->pNext = NULL;
1025                                 VFREE(szValue);
1026                                 pCardRaw += dLen;
1027                                 break;
1028                         case VCARD_TYPE_VALUE_STATUS:
1029                                 dLen = 0;
1030                                 temp = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, pVCard->pCur);
1031
1032                                 if (valueCount < VDATA_VALUE_COUNT_MAX) {
1033                                         pVCard->pCur->pszValue[valueCount] = temp;
1034                                         valueCount++;
1035                                         pVCard->pCur->valueCount = valueCount;
1036                                 } else
1037                                         VFREE(temp);
1038
1039                                 pCardRaw += dLen;
1040                                 break;
1041                 }
1042         }
1043
1044         VFREE(pCardRawTmp);
1045
1046         if (pVCard->pTop == NULL)
1047                 goto CATCH;
1048
1049         if (!vcard_ended) {
1050                 goto CATCH1;
1051         }
1052         VDATA_TRACE_END
1053         return pVCard;
1054
1055 CATCH:
1056         VFREE(pTemp);
1057 CATCH1:
1058         VFREE(pCardRawTmp);
1059         vcard_free_vtree_memory(pVCard);
1060         VDATA_TRACE_END
1061         return NULL;
1062 }
1063
1064 /*
1065  * vcard_encode() compares the string and vCard type, parameter value.
1066  *
1067  * @param       pVCardRaw            Data which will be encoded
1068  * @return      char *              Encoded result
1069  */
1070 char* vcard_encode(VTree *pVCardRaw)
1071 {
1072         VDATA_TRACE_BEGINE
1073         char*           pVCardRes = NULL;
1074         VObject *       pTmpObj =  NULL;
1075         char*           pTemp = NULL;
1076         int                     len;
1077         int                     total = 0;
1078         int             cnt = 0;
1079         int             lenTypeList = 0;
1080
1081         LENGTH_TYPE_LIST(pszCardTypeList, lenTypeList);
1082
1083         SysRequireEx(pVCardRaw != NULL, NULL);
1084         SysRequireEx(pVCardRaw->pTop != NULL, NULL);
1085         SysRequireEx(pVCardRaw->pTop->property >= 0, NULL);
1086         SysRequireEx(pVCardRaw->pTop->property < lenTypeList, NULL);
1087         SysRequireEx(pVCardRaw->treeType == VCARD, NULL);
1088         SysRequireEx(pVCardRaw->pTop->valueCount > 0, NULL);
1089
1090         //VDATA_TRACE("START %d %d", pVCardRaw->pTop->property, lenTypeList);
1091
1092         for (; cnt < pVCardRaw->pTop->valueCount; cnt++) {
1093
1094                 if (pVCardRaw->pTop->pszValue[cnt] == NULL)  {
1095                         VDATA_TRACE("pVCardRaw->pTop->valueCount : %d", pVCardRaw->pTop->valueCount);
1096                         VDATA_TRACE("pVCardRaw->pTop->pszValue[%d] : %s", cnt, pVCardRaw->pTop->pszValue[cnt]);
1097                         VDATA_TRACE_END
1098                         return NULL;
1099                 }
1100         }
1101         total += sizeof(char) * (14 + 14);
1102         if ((pVCardRes = (char *)calloc(1, total)) == NULL) {
1103                 VDATA_TRACE("vcard_encode:calloc failed\n");
1104                 VDATA_TRACE_END
1105                 return NULL;
1106         }
1107
1108         memcpy(pVCardRes, "BEGIN:VCARD\r\n", 14);
1109         g_strlcat(pVCardRes, "VERSION:2.1\r\n", total - strlen(pVCardRes));
1110
1111         pTmpObj = pVCardRaw->pTop;
1112
1113         while (true) {
1114                 if (pTmpObj == NULL)
1115                         break;
1116
1117                 if ((pTemp = __VCardTypeEncode(pTmpObj, pszCardTypeList[pTmpObj->property])) != NULL) {
1118                         len = strlen(pTemp);
1119                         total += len + sizeof(char) * 10;
1120                         if ((pVCardRes = (char*)realloc(pVCardRes, total)) == NULL) {
1121                                 VDATA_TRACE("vcard_encode():realloc failed\n");
1122                                 VFREE(pTemp);
1123                                 pTemp = NULL;
1124                                 VDATA_TRACE_END
1125                                 return NULL;
1126                         }
1127
1128                         if (strncmp(pTemp, "VERSION", strlen("VERSION")) != 0)
1129                                 g_strlcat(pVCardRes, pTemp, total - strlen(pVCardRes));
1130
1131                         VDATA_TRACE("pTemp : %s", pTemp);
1132
1133                         VFREE(pTemp);
1134                         pTemp = NULL;
1135                 }
1136
1137                 if (pTmpObj->pSibling != NULL)
1138                         pTmpObj = pTmpObj->pSibling;
1139                 else
1140                         break;
1141         }
1142
1143         total += sizeof(char) * 12;
1144         if ((pVCardRes = (char *)realloc(pVCardRes, total)) == NULL) {
1145                 VDATA_TRACE("vcard_encode:realloc failed\n");
1146                 VDATA_TRACE_END
1147                 return NULL;
1148         }
1149         g_strlcat(pVCardRes, "END:VCARD\r\n", total - strlen(pVCardRes));
1150         VDATA_TRACE_END
1151         return pVCardRes;
1152 }
1153
1154
1155 /*
1156  * VIsVcardFile() verify VCard file.
1157  *
1158  * @param       pVCardRaw           Data which will be encoded
1159  * @return      int                 result (true or false)
1160  */
1161 int
1162 __VIsVcardFile(char *pCardRaw, int mode)
1163 {
1164         int i = 0;
1165         bool rtnValue = true;
1166         char *pszVcardBegin = "BEGIN:VCARD";
1167
1168         switch (mode) {
1169                 case CHECK_START:
1170                         for (i = 0; i < 11; i++)
1171                                 if (*pszVcardBegin++ != *pCardRaw++)
1172                                         rtnValue = false;
1173                         break;
1174
1175                 default:
1176                         rtnValue = false;
1177         }
1178         VDATA_TRACE_END
1179         return rtnValue;
1180 }
1181
1182
1183 /*
1184  * vCardTypeEncoder() compares the string and vCard type, parameter value.
1185  *
1186  * @param               typeObj                         Data which will be encoded
1187  * @param               type                            Name of the type
1188  * @return      char *              Encoded result
1189  */
1190 char*
1191 __VCardTypeEncode(VObject *pTypeObj, char *pType)
1192 {
1193         VDATA_TRACE_BEGINE
1194         int                     len;
1195         char*           pTemp = NULL;
1196         char*           szTypeValue = NULL;
1197         int                     i;
1198         int                     enc = 0;
1199         char*           pEncode = NULL;
1200         char*           pRes = NULL;
1201         int                     total = 0;
1202         int                     biLen = 0;
1203
1204         len = strlen(pType);
1205         biLen = pTypeObj->numOfBiData;
1206
1207 #ifdef VDATA_GROUPNAME_SUPPORTED
1208         if (pTypeObj->pszGroupName != NULL) {
1209                 len += strlen(pTypeObj->pszGroupName) + 1;
1210         }
1211 #endif // VDATA_GROUPNAME_SUPPORTED
1212         if ((szTypeValue = (char *)calloc(1,  total += (len+1))) == NULL) {
1213                 VDATA_TRACE("__VCardTypeEncode():calloc failed\n");
1214                 VDATA_TRACE_END
1215                 return NULL;
1216         }
1217         memset(szTypeValue, '\0', (len+1));
1218 #ifdef VDATA_GROUPNAME_SUPPORTED
1219         if (pTypeObj->pszGroupName != NULL) {
1220                 g_strlcat(szTypeValue, pTypeObj->pszGroupName, total - strlen(szTypeValue));
1221                 g_strlcat(szTypeValue, ".", total - strlen(szTypeValue));
1222         }
1223 #endif // VDATA_GROUPNAME_SUPPORTED
1224         g_strlcat(szTypeValue, pType, total - strlen(szTypeValue));
1225
1226         pTemp = __VCardParamEncode(pTypeObj, &enc);
1227         if (pTemp != NULL) {
1228                 len = strlen(pTemp);
1229                 if ((szTypeValue = (char *)realloc(szTypeValue, (total += len))) == NULL) {
1230                         VDATA_TRACE("__VCardTypeEncode():realloc failed\n");
1231                         VFREE(pTemp);
1232                         pTemp = NULL
1233                         VDATA_TRACE_END;
1234                         return NULL;
1235                 }
1236                 g_strlcat(szTypeValue, pTemp, total - strlen(szTypeValue));
1237                 VFREE(pTemp);
1238                 pTemp = NULL;
1239         }
1240
1241         if ((szTypeValue = (char *)realloc(szTypeValue, (total += 2))) == NULL) {
1242                 VDATA_TRACE_END
1243                 return NULL;
1244         }
1245
1246         g_strlcat(szTypeValue, ":", total - strlen(szTypeValue));
1247
1248         len = 0;
1249
1250         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1251                 for (i = 0; i < pTypeObj->valueCount; i++) {
1252
1253                         if (pTypeObj->pszValue[i] != NULL)
1254                                 len += strlen(pTypeObj->pszValue[i]);
1255          }
1256         } else {
1257                 len += biLen;
1258         }
1259
1260         for (i = 0; i < pTypeObj->valueCount; i++) {
1261
1262                 if (i == 0) {
1263                         if ((pEncode = (char *)calloc(1,  len+20)) == NULL) {
1264                                 VFREE(szTypeValue);
1265                                 VDATA_TRACE_END
1266                                 return NULL;
1267                         }
1268
1269                         memset(pEncode, '\0', len+20);
1270
1271                         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1272                                 g_strlcat(pEncode, pTypeObj->pszValue[i], len+20 - strlen(pEncode));
1273                                 _VEscape(pEncode);
1274                         } else {
1275                                 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1276                         }
1277                 } else {
1278                         char    buf[1000];
1279                         strncpy(buf, pTypeObj->pszValue[i], 999);
1280                         _VEscape(buf);
1281                         g_strlcat(pEncode, ";", len+20 - strlen(pEncode));
1282                         g_strlcat(pEncode, buf, len+20 - strlen(pEncode));
1283                 }
1284         }
1285
1286         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1287                 if (pEncode) {
1288                         g_strlcat(pEncode, "\0\0", len+20 - strlen(pEncode));
1289                         len = strlen(pEncode);
1290                 }
1291         } else {
1292                 len = biLen;
1293         }
1294
1295         if (enc & pEncList[2].flag) {
1296                 if ((pRes = (char *)calloc(1, len * 6 + 10)) == NULL) {
1297                         VFREE(pEncode);
1298                         VFREE(szTypeValue);
1299                         VDATA_TRACE_END
1300                         return NULL;
1301                 }
1302                 if (pEncode)
1303                         _VQPEncode(pRes, pEncode);
1304                 VFREE(pEncode);
1305         } else if (enc & pEncList[1].flag) {
1306                 if ((pRes = (char *)calloc(1, (len * 8 / 6) + 4)) == NULL) {
1307                         VFREE(pEncode);
1308                         VFREE(szTypeValue);
1309                         VDATA_TRACE_END
1310                         return NULL;
1311                 }
1312
1313                 memset(pRes, '\0', ((len * 8 / 6) + 4));
1314                 _VB64Encode(pRes, pEncode, biLen);
1315                 VFREE(pEncode);
1316         } else {
1317                 if ((pRes = (char *)calloc(1, len+30)) == NULL) {
1318                         VFREE(pEncode);
1319                         VFREE(szTypeValue);
1320                         VDATA_TRACE_END
1321                         return NULL;
1322                 }
1323                 memset(pRes, '\0', (len + 30));
1324                 if (pEncode) {
1325                         memcpy(pRes, pEncode, len);
1326                         VFREE(pEncode);
1327                 }
1328         }
1329
1330         if ((pRes = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL) {
1331                 VFREE(pEncode);
1332                 VFREE(szTypeValue);
1333                 VDATA_TRACE_END
1334                 return NULL;
1335         }
1336         g_strlcat(pRes, "\r\n", 2);
1337
1338         len = strlen(pRes);
1339
1340         if ((szTypeValue = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1341                 VFREE(pEncode);
1342                 VFREE(pRes);
1343                 VDATA_TRACE_END
1344                 return NULL;
1345         }
1346
1347         g_strlcat(szTypeValue, pRes, total - strlen(szTypeValue));
1348
1349         if (strcmp(pType, pszCardTypeList[19]) != 0) {
1350                 _VRLSpace(szTypeValue);
1351                 _VRTSpace(szTypeValue);
1352         }
1353
1354         VFREE(pRes);
1355         VDATA_TRACE_END
1356         return szTypeValue;
1357 }
1358
1359 /**
1360  * __VCardParamEncode() Parameter Encoding.
1361  *
1362  * @param               pTypeObj                Data which will be encoded
1363  * @param               pEnc                            Name of the type
1364  */
1365 char *
1366 __VCardParamEncode(VObject* pTypeObj, int* pEnc)
1367 {
1368         VDATA_TRACE_BEGINE
1369         int i = 0;
1370         int len = 0;
1371         int sNum = 0;
1372         int shift = 0;
1373         bool bSupported;
1374         char* szParam = NULL;
1375         VParam* pTemp = NULL;
1376         ValueObj*       pList = NULL;
1377
1378         /** Paramter initialize. */
1379         pTemp = pTypeObj->pParam;
1380
1381         /** Momory Allocation for parameter string. */
1382         if (pTemp != NULL) {
1383                 if ((szParam = (char*)calloc(1, len += 2)) == NULL) {
1384                         VDATA_TRACE_END
1385                         return NULL;
1386                 }
1387                 memset(szParam, 0x00, 2);
1388         }
1389
1390         /** appending pamaters. */
1391         while (true) {
1392
1393                 if (pTemp == NULL) break;
1394
1395                 bSupported = false;
1396
1397                 /** Expand szParam string. For appending.*/
1398                 if ((szParam = (char *)realloc(szParam, len += 15)) == NULL) {
1399                         VDATA_TRACE_END
1400                         return NULL;
1401                 }
1402
1403                 /** appending paramter name. */
1404                 g_strlcat(szParam, ";", len - strlen(szParam));
1405                 if (pTemp->parameter != VCARD_PARAM_TYPE) {
1406                         g_strlcat(szParam, pszCardParamList[pTemp->parameter], len - strlen(szParam));
1407                         g_strlcat(szParam, "=", len - strlen(szParam));
1408                 }
1409
1410                 /** Set Parameter Value name. */
1411                 switch (pTemp->parameter) {
1412                         case VCARD_PARAM_ENCODING:
1413                                 *pEnc = pTemp->paramValue;
1414                                 shift = VCARD_ENCODE_PARAM_NUM;
1415                                 pList = pEncList; bSupported = true;
1416                                 break;
1417                         case VCARD_PARAM_TYPE:
1418                                 shift = VCARD_TYPE_PARAM_NUM;
1419                                 pList = pTypeList; bSupported = true;
1420                                 break;
1421                         case VCARD_PARAM_VALUE:
1422                                 shift = VCARD_VALUE_PARAM_NUM;
1423                                 pList = pValueList; bSupported = true;
1424                                 break;
1425                         case VCARD_PARAM_CHARSET:
1426                                 shift = VCARD_CHARSET_PARAM_NUM;
1427                                 pList = pCharsetList; bSupported = true;
1428                                 break;
1429                         default:
1430                                 if ((szParam = (char*)realloc(szParam, 5)) == NULL) {
1431                                         VDATA_TRACE_END
1432                                         return NULL;
1433                                 }
1434                                 g_strlcat(szParam, "NONE", 5 - strlen(szParam));
1435                 }
1436
1437                 /** exchage parameter value's to string.*/
1438                 if (bSupported == true) {
1439
1440                         for (i = 0, sNum = 0x00000001; i < shift; i++) {
1441
1442                                 if (pTemp->paramValue & sNum) {
1443                                         if ((szParam = (char *)realloc(szParam, (len += (strlen(pList[i].szName) + 2)))) == NULL) {
1444                                                 VDATA_TRACE_END
1445                                                 return NULL;
1446                                         }
1447
1448                                         g_strlcat(szParam, pList[i].szName, len - strlen(szParam));
1449                                         g_strlcat(szParam, "; ", len - strlen(szParam));
1450                                 }
1451
1452                                 sNum <<= 1;
1453                         }
1454                 }
1455
1456                 /** remove semicolon from tail. */
1457                 for (i = strlen(szParam); i > 0 ; i--) {
1458
1459                         if (szParam[i] == ' ' && szParam[i-1] == ';') {
1460                                 szParam[i-1] = '\0';
1461                                 break;
1462                         }
1463                 }
1464
1465                 if (pTemp->pNext != NULL)
1466                         pTemp = pTemp->pNext;
1467                 else
1468                         break;
1469         }
1470         VDATA_TRACE_END
1471         return szParam;
1472 }
1473
1474 bool vcard_free_vtree_memory(VTree * pTree)
1475 {
1476         VDATA_TRACE_BEGINE
1477         if (pTree == NULL) {
1478                 VDATA_TRACE_END
1479                 return false;
1480         }
1481         VDATA_TRACE_END
1482         return __VCardFreeVTreeMemory(pTree);
1483 }
1484