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 == NULL)
 931                                         goto CATCH;
 932
 933                                 if (pVCard->pTop == NULL) {
 934                                         pVCard->pTop = pTemp;
 935                                         pVCard->pCur = pTemp;
 936                                 } else {
 937                                         pVCard->pCur->pSibling = pTemp;
 938                                         pVCard->pCur = pTemp;
 939                                 }
 940
 941                                 break;
 942                         }
 943
 944                         numberedParam = 0;
 945                         param_status = false;
 946                         valueCount = 0;
 947
 948 #ifdef VDATA_GROUPNAME_SUPPORTED
 949                         if (gszGroupName != NULL)
 950                                 pVCard->pCur->pszGroupName = gszGroupName;
 951 #endif
 952                         break;
 953
 954                 case VCARD_PARAM_NAME_STATUS:
 955                 {
 956                         dLen = 0;
 957                         param = __VCardGetParamName(pCardRaw, &status, &dLen);
 958                         pCardRaw += dLen;
 959
 960                         if (param_status != true) {
 961
 962                                 if ((pTmpParam = (VParam*)calloc(1,  sizeof(VParam))) == NULL)
 963                                                 goto CATCH;
 964
 965                                 param_status = true;
 966                                 pVCard->pCur->pParam = pTmpParam;
 967                                 memset(pTmpParam, 0x00, sizeof(VParam));
 968                                 VDATA_TRACE("pTmpParam : %p", pTmpParam);
 969                         } else {
 970                                 if ((pTmpParam->pNext = (VParam*)calloc(1,  sizeof(VParam))) == NULL)
 971                                         goto CATCH;
 972
 973                                 pTmpParam = pTmpParam->pNext;
 974                                 memset(pTmpParam, 0x00, sizeof(VParam));
 975                                 VDATA_TRACE("pTmpParam : %p", pTmpParam);
 976                         }
 977
 978                         pTmpParam->parameter = param;
 979                         break;
 980                 }
 981                 case VCARD_PARAM_VALUE_STATUS:
 982                         dLen = 0;
 983                         numberedParam = 0;
 984                         switch (pTmpParam->parameter) {
 985                         case VCARD_PARAM_TYPE:
 986                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 987                                 numberedParam |= __VCardGetValue(szValue, pTypeList, VCARD_TYPE_PARAM_NUM);
 988                                 break;
 989                         case VCARD_PARAM_VALUE:
 990                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 991                                 numberedParam |= __VCardGetValue(szValue, pValueList, VCARD_VALUE_PARAM_NUM);
 992                                 break;
 993                         case VCARD_PARAM_ENCODING:
 994                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
 995                                 numberedParam |= __VCardGetValue(szValue, pEncList, VCARD_ENCODE_PARAM_NUM);
 996                                 enc = numberedParam;
 997                                 break;
 998                         case VCARD_PARAM_CHARSET:
 999                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1000                                 numberedParam |= __VCardGetValue(szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM);
1001                                 break;
1002                         case VCARD_PARAM_CONTEXT:
1003                         case VCARD_PARAM_LANGUAGE:
1004                                 /* prevent 7605 08.03.13 */
1005                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1006                                 numberedParam = 0;
1007                                 break;
1008                         default:
1009                                 szValue = __VCardGetParamVal(pCardRaw, &status, &dLen);
1010
1011                                 SET_PARAM_VALUE(numberedParam, szValue, pTypeList, VCARD_TYPE_PARAM_NUM, pTmpParam, VCARD_PARAM_TYPE, enc);
1012                                 SET_PARAM_VALUE(numberedParam, szValue, pValueList, VCARD_VALUE_PARAM_NUM, pTmpParam, VCARD_PARAM_VALUE, enc);
1013                                 SET_PARAM_VALUE(numberedParam, szValue, pEncList, VCARD_ENCODE_PARAM_NUM, pTmpParam, VCARD_PARAM_ENCODING, enc);
1014                                 SET_PARAM_VALUE(numberedParam, szValue, pCharsetList, VCARD_CHARSET_PARAM_NUM, pTmpParam, VCARD_PARAM_CHARSET, enc);
1015
1016                                 numberedParam = 0;
1017                                 pCardRaw += dLen;
1018                                 dLen = 0;
1019
1020                                 break;
1021                         }
1022
1023                         VDATA_TRACE("%d, %s, %p", numberedParam, szValue, pTmpParam);
1024                         pTmpParam->paramValue = numberedParam;
1025                         pTmpParam->pNext = NULL;
1026                         VFREE(szValue);
1027                         pCardRaw += dLen;
1028                         break;
1029                 case VCARD_TYPE_VALUE_STATUS:
1030                         dLen = 0;
1031                         temp = __VCardGetTypeVal(pCardRaw, &status, &dLen, enc, pVCard->pCur);
1032
1033                         if (valueCount < VDATA_VALUE_COUNT_MAX) {
1034                                 pVCard->pCur->pszValue[valueCount] = temp;
1035                                 valueCount++;
1036                                 pVCard->pCur->valueCount = valueCount;
1037                         } else
1038                                 VFREE(temp);
1039
1040                         pCardRaw += dLen;
1041                         break;
1042                 }
1043         }
1044
1045         VFREE(pCardRawTmp);
1046
1047         if (pVCard == NULL || pVCard->pTop == NULL)
1048                 goto CATCH;
1049
1050         if (!vcard_ended)
1051                 goto CATCH1;
1052
1053         VDATA_TRACE_END
1054         return pVCard;
1055
1056 CATCH:
1057         VFREE(pTemp);
1058 CATCH1:
1059         VFREE(pCardRawTmp);
1060         vcard_free_vtree_memory(pVCard);
1061         VDATA_TRACE_END
1062         return NULL;
1063 }
1064
1065 /*
1066  * vcard_encode() compares the string and vCard type, parameter value.
1067  *
1068  * @param       pVCardRaw            Data which will be encoded
1069  * @return      char *              Encoded result
1070  */
1071 char* vcard_encode(VTree *pVCardRaw)
1072 {
1073         VDATA_TRACE_BEGINE
1074         char*           pVCardRes = NULL;
1075         char*           pTempVCard = NULL;
1076         VObject *       pTmpObj =  NULL;
1077         char*           pTemp = NULL;
1078         int                     len;
1079         int                     total = 0;
1080         int                     cnt = 0;
1081         int                     lenTypeList = 0;
1082
1083         LENGTH_TYPE_LIST(pszCardTypeList, lenTypeList);
1084
1085         SysRequireEx(pVCardRaw != NULL, NULL);
1086         SysRequireEx(pVCardRaw->pTop != NULL, NULL);
1087         SysRequireEx(pVCardRaw->pTop->property >= 0, NULL);
1088         SysRequireEx(pVCardRaw->pTop->property < lenTypeList, NULL);
1089         SysRequireEx(pVCardRaw->treeType == VCARD, NULL);
1090         SysRequireEx(pVCardRaw->pTop->valueCount > 0, NULL);
1091
1092         /* VDATA_TRACE("START %d %d", pVCardRaw->pTop->property, lenTypeList); */
1093
1094         for (; cnt < pVCardRaw->pTop->valueCount; cnt++) {
1095
1096                 if (pVCardRaw->pTop->pszValue[cnt] == NULL)  {
1097                         VDATA_TRACE("pVCardRaw->pTop->valueCount : %d", pVCardRaw->pTop->valueCount);
1098                         VDATA_TRACE("pVCardRaw->pTop->pszValue[%d] : %s", cnt, pVCardRaw->pTop->pszValue[cnt]);
1099                         VDATA_TRACE_END
1100                         return NULL;
1101                 }
1102         }
1103         total += sizeof(char) * (14 + 14);
1104         if ((pVCardRes = (char *)calloc(1, total)) == NULL) {
1105                 VDATA_TRACE("vcard_encode:calloc failed\n");
1106                 VDATA_TRACE_END
1107                 return NULL;
1108         }
1109
1110         memcpy(pVCardRes, "BEGIN:VCARD\r\n", 14);
1111         g_strlcat(pVCardRes, "VERSION:2.1\r\n", total - strlen(pVCardRes));
1112
1113         pTmpObj = pVCardRaw->pTop;
1114
1115         while (true) {
1116                 if (pTmpObj == NULL)
1117                         break;
1118
1119                 if ((pTemp = __VCardTypeEncode(pTmpObj, pszCardTypeList[pTmpObj->property])) != NULL) {
1120                         len = strlen(pTemp);
1121                         total += len + sizeof(char) * 10;
1122                         if ((pTempVCard = (char*)realloc(pVCardRes, total)) == NULL) {
1123                                 VDATA_TRACE("vcard_encode():realloc failed\n");
1124                                 VFREE(pTemp);
1125                                 pTemp = NULL;
1126                                 VFREE(pVCardRes);
1127                                 VDATA_TRACE_END
1128                                 return NULL;
1129                         }
1130                         pVCardRes = pTempVCard;
1131
1132                         if (strncmp(pTemp, "VERSION", strlen("VERSION")) != 0)
1133                                 g_strlcat(pVCardRes, pTemp, total - strlen(pVCardRes));
1134
1135                         VDATA_TRACE("pTemp : %s", pTemp);
1136
1137                         VFREE(pTemp);
1138                         pTemp = NULL;
1139                 }
1140
1141                 if (pTmpObj->pSibling != NULL)
1142                         pTmpObj = pTmpObj->pSibling;
1143                 else
1144                         break;
1145         }
1146
1147         total += sizeof(char) * 12;
1148         if ((pTempVCard = (char *)realloc(pVCardRes, total)) == NULL) {
1149                 VDATA_TRACE("vcard_encode:realloc failed\n");
1150                 VFREE(pVCardRes);
1151                 VDATA_TRACE_END
1152                 return NULL;
1153         }
1154         pVCardRes = pTempVCard;
1155         g_strlcat(pVCardRes, "END:VCARD\r\n", total - strlen(pVCardRes));
1156         VDATA_TRACE_END
1157         return pVCardRes;
1158 }
1159
1160
1161 /*
1162  * VIsVcardFile() verify VCard file.
1163  *
1164  * @param       pVCardRaw           Data which will be encoded
1165  * @return      int                 result (true or false)
1166  */
1167 int
1168 __VIsVcardFile(char *pCardRaw, int mode)
1169 {
1170         int i = 0;
1171         bool rtnValue = true;
1172         char *pszVcardBegin = "BEGIN:VCARD";
1173
1174         switch (mode) {
1175         case CHECK_START:
1176                 for (i = 0; i < 11; i++)
1177                         if (*pszVcardBegin++ != *pCardRaw++)
1178                                 rtnValue = false;
1179                 break;
1180
1181         default:
1182                 rtnValue = false;
1183         }
1184         VDATA_TRACE_END
1185         return rtnValue;
1186 }
1187
1188
1189 /*
1190  * vCardTypeEncoder() compares the string and vCard type, parameter value.
1191  *
1192  * @param               typeObj                         Data which will be encoded
1193  * @param               type                            Name of the type
1194  * @return      char *              Encoded result
1195  */
1196 char*
1197 __VCardTypeEncode(VObject *pTypeObj, char *pType)
1198 {
1199         VDATA_TRACE_BEGINE
1200         int                     len;
1201         char*           pTemp = NULL;
1202         char*           szTypeValue = NULL;
1203         char*           szTemp = NULL;
1204         int                     i;
1205         int                     enc = 0;
1206         char*           pEncode = NULL;
1207         char*           pRes = NULL;
1208         int                     total = 0;
1209         int                     biLen = 0;
1210
1211         len = strlen(pType);
1212         biLen = pTypeObj->numOfBiData;
1213
1214 #ifdef VDATA_GROUPNAME_SUPPORTED
1215         if (pTypeObj->pszGroupName != NULL)
1216                 len += strlen(pTypeObj->pszGroupName) + 1;
1217 #endif /* VDATA_GROUPNAME_SUPPORTED */
1218
1219         if ((szTypeValue = (char *)calloc(1,  total += (len+1))) == NULL) {
1220                 VDATA_TRACE("__VCardTypeEncode():calloc failed\n");
1221                 VDATA_TRACE_END
1222                 return NULL;
1223         }
1224         memset(szTypeValue, '\0', (len+1));
1225 #ifdef VDATA_GROUPNAME_SUPPORTED
1226         if (pTypeObj->pszGroupName != NULL) {
1227                 g_strlcat(szTypeValue, pTypeObj->pszGroupName, total - strlen(szTypeValue));
1228                 g_strlcat(szTypeValue, ".", total - strlen(szTypeValue));
1229         }
1230 #endif /* VDATA_GROUPNAME_SUPPORTED */
1231         g_strlcat(szTypeValue, pType, total - strlen(szTypeValue));
1232
1233         pTemp = __VCardParamEncode(pTypeObj, &enc);
1234         if (pTemp != NULL) {
1235                 len = strlen(pTemp);
1236                 if ((szTemp = (char *)realloc(szTypeValue, (total += len))) == NULL) {
1237                         VDATA_TRACE("__VCardTypeEncode():realloc failed\n");
1238                         VFREE(pTemp);
1239                         pTemp = NULL;
1240                         VFREE(szTypeValue);
1241                         VDATA_TRACE_END
1242                         return NULL;
1243                 } else {
1244                         szTypeValue = szTemp;
1245                 }
1246                 g_strlcat(szTypeValue, pTemp, total - strlen(szTypeValue));
1247                 VFREE(pTemp);
1248                 pTemp = NULL;
1249         }
1250
1251         if ((szTemp = (char *)realloc(szTypeValue, (total += 2))) == NULL) {
1252                 VFREE(szTypeValue);
1253                 VDATA_TRACE_END
1254                 return NULL;
1255         } else {
1256                 szTypeValue = szTemp;
1257         }
1258
1259         g_strlcat(szTypeValue, ":", total - strlen(szTypeValue));
1260
1261         len = 0;
1262
1263         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1264                 for (i = 0; i < pTypeObj->valueCount; i++) {
1265
1266                         if (pTypeObj->pszValue[i] != NULL)
1267                                 len += strlen(pTypeObj->pszValue[i]);
1268                 }
1269         } else {
1270                 len += biLen;
1271         }
1272
1273         for (i = 0; i < pTypeObj->valueCount; i++) {
1274
1275                 if (i == 0) {
1276                         if ((pEncode = (char *)calloc(1,  len+20)) == NULL) {
1277                                 VFREE(szTypeValue);
1278                                 VDATA_TRACE_END
1279                                 return NULL;
1280                         }
1281
1282                         memset(pEncode, '\0', len+20);
1283
1284                         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1285                                 g_strlcat(pEncode, pTypeObj->pszValue[i], len+20 - strlen(pEncode));
1286                                 _VEscape(pEncode);
1287                         } else {
1288                                 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1289                         }
1290                 } else {
1291                         char    buf[1000];
1292                         strncpy(buf, pTypeObj->pszValue[i], 999);
1293                         _VEscape(buf);
1294                         g_strlcat(pEncode, ";", len+20 - strlen(pEncode));
1295                         g_strlcat(pEncode, buf, len+20 - strlen(pEncode));
1296                 }
1297         }
1298
1299         if (strcmp(pType, pszCardTypeList[19]) != 0)    {
1300                 if (pEncode) {
1301                         g_strlcat(pEncode, "\0\0", len+20 - strlen(pEncode));
1302                         len = strlen(pEncode);
1303                 }
1304         } else {
1305                 len = biLen;
1306         }
1307
1308         if (enc & pEncList[2].flag) {
1309                 if ((pRes = (char *)calloc(1, len * 6 + 10)) == NULL) {
1310                         VFREE(pEncode);
1311                         VFREE(szTypeValue);
1312                         VDATA_TRACE_END
1313                         return NULL;
1314                 }
1315                 if (pEncode)
1316                         _VQPEncode(pRes, pEncode);
1317                 VFREE(pEncode);
1318         } else if (enc & pEncList[1].flag) {
1319                 if ((pRes = (char *)calloc(1, (len * 8 / 6) + 4)) == NULL) {
1320                         VFREE(pEncode);
1321                         VFREE(szTypeValue);
1322                         VDATA_TRACE_END
1323                         return NULL;
1324                 }
1325
1326                 memset(pRes, '\0', ((len * 8 / 6) + 4));
1327                 _VB64Encode(pRes, pEncode, biLen);
1328                 VFREE(pEncode);
1329         } else {
1330                 if ((pRes = (char *)calloc(1, len+30)) == NULL) {
1331                         VFREE(pEncode);
1332                         VFREE(szTypeValue);
1333                         VDATA_TRACE_END
1334                         return NULL;
1335                 }
1336                 memset(pRes, '\0', (len + 30));
1337                 if (pEncode) {
1338                         memcpy(pRes, pEncode, len);
1339                         VFREE(pEncode);
1340                 }
1341         }
1342
1343         if ((szTemp = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL) {
1344                 VFREE(pEncode);
1345                 VFREE(szTypeValue);
1346                 VFREE(pRes);
1347                 VDATA_TRACE_END
1348                 return NULL;
1349         } else {
1350                 pRes = szTemp;
1351         }
1352         g_strlcat(pRes, "\r\n", 2);
1353
1354         len = strlen(pRes);
1355
1356         if ((szTemp = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1357                 VFREE(pEncode);
1358                 VFREE(pRes);
1359                 VFREE(szTypeValue);
1360                 VDATA_TRACE_END
1361                 return NULL;
1362         } else {
1363                 szTypeValue = szTemp;
1364         }
1365
1366         g_strlcat(szTypeValue, pRes, total - strlen(szTypeValue));
1367
1368         if (strcmp(pType, pszCardTypeList[19]) != 0) {
1369                 _VRLSpace(szTypeValue);
1370                 _VRTSpace(szTypeValue);
1371         }
1372
1373         VFREE(pRes);
1374         VDATA_TRACE_END
1375         return szTypeValue;
1376 }
1377
1378 /**
1379  * __VCardParamEncode() Parameter Encoding.
1380  *
1381  * @param               pTypeObj                Data which will be encoded
1382  * @param               pEnc                            Name of the type
1383  */
1384 char *
1385 __VCardParamEncode(VObject* pTypeObj, int* pEnc)
1386 {
1387         VDATA_TRACE_BEGINE
1388         int i = 0;
1389         int len = 0;
1390         int sNum = 0;
1391         int shift = 0;
1392         bool bSupported;
1393         char* szParam = NULL;
1394         char* szTemp = NULL;
1395         VParam* pTemp = NULL;
1396         ValueObj*       pList = NULL;
1397
1398         /** Paramter initialize. */
1399         pTemp = pTypeObj->pParam;
1400
1401         /** Momory Allocation for parameter string. */
1402         if (pTemp != NULL) {
1403                 if ((szParam = (char*)calloc(1, len += 2)) == NULL) {
1404                         VDATA_TRACE_END
1405                         return NULL;
1406                 }
1407                 memset(szParam, 0x00, 2);
1408         }
1409
1410         /** appending pamaters. */
1411         while (true) {
1412
1413                 if (pTemp == NULL) break;
1414
1415                 bSupported = false;
1416
1417                 /** Expand szParam string. For appending.*/
1418                 if ((szTemp = (char *)realloc(szParam, len += 15)) == NULL) {
1419                         VFREE(szParam);
1420                         VDATA_TRACE_END
1421                         return NULL;
1422                 } else {
1423                         szParam = szTemp;
1424                 }
1425
1426                 /** appending paramter name. */
1427                 g_strlcat(szParam, ";", len - strlen(szParam));
1428                 if (pTemp->parameter != VCARD_PARAM_TYPE) {
1429                         g_strlcat(szParam, pszCardParamList[pTemp->parameter], len - strlen(szParam));
1430                         g_strlcat(szParam, "=", len - strlen(szParam));
1431                 }
1432
1433                 /** Set Parameter Value name. */
1434                 switch (pTemp->parameter) {
1435                 case VCARD_PARAM_ENCODING:
1436                         *pEnc = pTemp->paramValue;
1437                         shift = VCARD_ENCODE_PARAM_NUM;
1438                         pList = pEncList; bSupported = true;
1439                         break;
1440                 case VCARD_PARAM_TYPE:
1441                         shift = VCARD_TYPE_PARAM_NUM;
1442                         pList = pTypeList; bSupported = true;
1443                         break;
1444                 case VCARD_PARAM_VALUE:
1445                         shift = VCARD_VALUE_PARAM_NUM;
1446                         pList = pValueList; bSupported = true;
1447                         break;
1448                 case VCARD_PARAM_CHARSET:
1449                         shift = VCARD_CHARSET_PARAM_NUM;
1450                         pList = pCharsetList; bSupported = true;
1451                         break;
1452                 default:
1453                         if ((szTemp = (char*)realloc(szParam, 5)) == NULL) {
1454                                 VFREE(szParam);
1455                                 VDATA_TRACE_END
1456                                 return NULL;
1457                         } else {
1458                                 szParam = szTemp;
1459                         }
1460                         g_strlcat(szParam, "NONE", 5 - strlen(szParam));
1461                 }
1462
1463                 /** exchage parameter value's to string.*/
1464                 if (bSupported == true) {
1465
1466                         for (i = 0, sNum = 0x00000001; i < shift; i++) {
1467
1468                                 if (pTemp->paramValue & sNum) {
1469                                         if ((szTemp = (char *)realloc(szParam, (len += (strlen(pList[i].szName) + 2)))) == NULL) {
1470                                                 VFREE(szParam);
1471                                                 VDATA_TRACE_END
1472                                                 return NULL;
1473                                         } else {
1474                                                 szParam = szTemp;
1475                                         }
1476
1477                                         g_strlcat(szParam, pList[i].szName, len - strlen(szParam));
1478                                         g_strlcat(szParam, "; ", len - strlen(szParam));
1479                                 }
1480
1481                                 sNum <<= 1;
1482                         }
1483                 }
1484
1485                 /** remove semicolon from tail. */
1486                 for (i = strlen(szParam); i > 0 ; i--) {
1487
1488                         if (szParam[i] == ' ' && szParam[i-1] == ';') {
1489                                 szParam[i-1] = '\0';
1490                                 break;
1491                         }
1492                 }
1493
1494                 if (pTemp->pNext != NULL)
1495                         pTemp = pTemp->pNext;
1496                 else
1497                         break;
1498         }
1499         VDATA_TRACE_END
1500         return szParam;
1501 }
1502
1503 bool vcard_free_vtree_memory(VTree * pTree)
1504 {
1505         VDATA_TRACE_BEGINE
1506         if (pTree == NULL) {
1507                 VDATA_TRACE_END
1508                 return false;
1509         }
1510         VDATA_TRACE_END
1511         return __VCardFreeVTreeMemory(pTree);
1512 }
1513