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