vobject-engine/VMessage.c

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