vobject-engine/VCard.c

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