vobject-engine/VCard.c

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