vobject-engine/VMessage.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 "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 *)malloc(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 *)malloc(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 *)malloc(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 *)malloc(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 *)malloc(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         len = _VUnfoldingNoSpec(pMsgRaw, VMESSAGE);
 839         pMsgRawTmp = pMsgRaw;
 840         len = _VManySpace2Space( pMsgRaw );
 841
 842         if(!__VIsVmsgFile(pMsgRaw, CHECK_START)) {
 843                 VFREE(pMsgRawTmp);
 844                 VDATA_TRACE_END
 845                 return NULL;
 846         }
 847
 848         while(true && !done)
 849         {
 850                 c = *pMsgRaw;
 851
 852                 if((c == '\0') || done)
 853                         break;
 854
 855                 switch(status) {
 856                         case VMSG_TYPE_NAME_STATUS:
 857                                 dLen = 0;
 858                                 type = __VMsgGetTypeName(pMsgRaw, &status, &dLen);
 859
 860                                 if(type == VMSG_TYPE_BEGIN)
 861                                         pVTree = pMsgRaw;
 862
 863                                 pMsgRaw += dLen;
 864
 865                                 if(type == -1)
 866                                         break;
 867
 868                                 switch ( type )
 869                                 {
 870                                         case VMSG_TYPE_BEGIN:
 871                                                 dLen = 0;
 872                                                 enc = 0;
 873                                                 szMsgBegin = __VMsgGetTypeVal(pMsgRaw, &status, &dLen, enc, NULL);
 874                                                 pMsgRaw += dLen;
 875
 876                                                 if(szMsgBegin == NULL)
 877                                                         goto CATCH;
 878
 879                                                 if(!strncmp(szMsgBegin, "VCARD", strlen("VCARD")))
 880                                                 {
 881                                                         VDATA_TRACE("pVTree: %s", pVTree);
 882                                                         pVCard = vcard_decode(pVTree);
 883                                                         pCurrent->pNext = pVCard;
 884                                                         pCurrent = pVCard;
 885
 886                                                         dLen = ((strstr(pMsgRaw,"END:VCARD") + 9) - pMsgRaw);
 887                                                         pMsgRaw += dLen;
 888                                                 }
 889
 890                                                 else
 891                                                 {
 892
 893                                                         if(start_status == 1)
 894                                                                 goto CATCH;
 895
 896
 897
 898
 899                                                         if(!strncmp(szMsgBegin, "VMSG", strlen("VMSG")))
 900                                                         {
 901                                                                 if ( ( pVMsg = ( VTree* )malloc( sizeof( VTree ) ) ) == NULL )
 902                                                                 {
 903                                                                         start_status = 1;
 904                                                                         goto CATCH;
 905                                                                 }
 906                                                                 memset(pVMsg,0x00, sizeof(VTree));
 907
 908                                                                 pVMsg->treeType = VMESSAGE;
 909                                                                 pVMsg->pTop = NULL;
 910                                                                 pVMsg->pCur = NULL;
 911                                                                 pVMsg->pNext = NULL;
 912                                                                 pCurrent = pVMsg;
 913                                                         }
 914
 915                                                         else if(!strncmp(szMsgBegin, "VBODY", strlen("VBODY")))
 916                                                         {
 917                                                                 if ( ( pVBody = ( VTree* )malloc( sizeof( VTree ) ) ) == NULL )
 918                                                                 {
 919                                                                         start_status = 1;
 920                                                                         goto CATCH;
 921                                                                 }
 922
 923                                                                 memset(pVBody,0x00, sizeof(VTree));
 924                                                                 pVBody->treeType = VBODY;
 925                                                                 pVBody->pTop = NULL;
 926                                                                 pVBody->pCur = NULL;
 927                                                                 pVBody->pNext = NULL;
 928                                                                 pCurrent->pNext = pVBody;
 929                                                                 pCurrent = pVBody;
 930                                                         }
 931                                                 }
 932
 933                                                 VFREE(szMsgBegin);
 934                                                 break;
 935
 936                                         case VMSG_TYPE_END:
 937                                                 dLen = 0;
 938                                                 enc = 0;
 939                                                 //szMsgBegin = __VMsgGetTypeVal(pMsgRaw, &status, &dLen, enc, NULL);
 940
 941                                                 if(!strncmp(pMsgRaw,"VMSG", strlen("VMSG")))
 942                                                 {
 943                                                         done = true;
 944                                                         vmsg_ended = true;
 945                                                 }
 946                                                 else
 947                                                 {
 948                                                         status = VMSG_TYPE_NAME_STATUS;
 949                                                         //pMsgRaw += dLen;
 950                                                 }
 951                                                 VDATA_TRACE("pMsgRaw:%s", pMsgRaw);
 952                                                 pMsgRaw += dLen;
 953                                                 break;
 954
 955                                         case UNKNOWN_NAME :
 956                                                 break;
 957
 958                                         default:
 959                                                 if(UNKNOWN_NAME == type || type < 0) {
 960                                                         status = VMSG_TYPE_NAME_STATUS;
 961                                                         break;
 962                                                 }
 963
 964                                                 if ( ( pTemp = ( VObject* )malloc( sizeof( VObject ) ) ) == NULL )
 965                                                 {
 966                                                         goto CATCH;
 967                                                 }
 968
 969                                                 memset( pTemp, 0, sizeof( VObject ) );
 970                                                 pTemp->property = type;
 971
 972                                                 if ( pCurrent->pTop == NULL ) {
 973                                                         pCurrent->pTop = pTemp;
 974                                                         pCurrent->pCur = pTemp;
 975                                                 }
 976                                                 else {
 977                                                         pCurrent->pCur->pSibling = pTemp;
 978                                                         pCurrent->pCur = pTemp;
 979                                                 }
 980
 981                                                 break;
 982                                 }
 983
 984                                 numberedParam = 0;
 985                                 param_status = false;
 986                                 valueCount = 0;
 987                                 break;
 988
 989                         case VMSG_PARAM_NAME_STATUS:
 990                         {
 991                                 dLen = 0;
 992                                 param = __VMsgGetParamName( pMsgRaw, &status, &dLen );
 993                                 pMsgRaw += dLen;
 994
 995                                 if ( param_status != true ) {
 996
 997                                         if ( ( pTmpParam = ( VParam* )malloc( sizeof( VParam ) ) ) == NULL )
 998                                                         goto CATCH;
 999
1000                                         param_status = true;
1001                                         pCurrent->pCur->pParam = pTmpParam;
1002                                         memset( pTmpParam, 0x00, sizeof( VParam ) );
1003                                         VDATA_TRACE("pTmpParam : %p", pTmpParam);
1004                                 }
1005                                 else
1006                                 {
1007                                         if ( ( pTmpParam->pNext = ( VParam* )malloc( sizeof( VParam ) ) ) == NULL )
1008                                                         goto CATCH;
1009
1010                                         pTmpParam = pTmpParam->pNext;
1011                                         memset( pTmpParam, 0x00, sizeof(VParam));
1012                                         VDATA_TRACE("pTmpParam : %p", pTmpParam);
1013                                 }
1014
1015                                 pTmpParam->parameter = param;
1016                                 break;
1017                         }
1018                         case VMSG_PARAM_VALUE_STATUS:
1019                                 dLen = 0;
1020                                 numberedParam = 0;
1021                                 switch ( pTmpParam->parameter )
1022                                 {
1023                                         case VMSG_PARAM_TYPE:
1024                                                 szValue = __VMsgGetParamVal( pMsgRaw, &status, &dLen );
1025                                                 numberedParam |= __VMsgGetValue( szValue, pMsgTypeList, VMSG_TYPE_PARAM_NUM );
1026                                                 break;
1027                                         case VMSG_PARAM_VALUE:
1028                                                 szValue = __VMsgGetParamVal( pMsgRaw, &status, &dLen );
1029                                                 numberedParam |= __VMsgGetValue( szValue, pMsgValueList, VMSG_VALUE_PARAM_NUM );
1030                                                 break;
1031                                         case VMSG_PARAM_ENCODING:
1032                                                 szValue = __VMsgGetParamVal( pMsgRaw, &status, &dLen );
1033                                                 numberedParam |= __VMsgGetValue( szValue, pMsgEncList, VMSG_ENCODE_PARAM_NUM );
1034                                                 enc = numberedParam;
1035                                                 break;
1036                                         case VMSG_PARAM_CHARSET:
1037                                                 szValue = __VMsgGetParamVal( pMsgRaw, &status, &dLen );
1038                                                 numberedParam |= __VMsgGetValue( szValue, pMsgCharsetList, VMSG_CHARSET_PARAM_NUM );
1039                                                 break;
1040                                         case VMSG_PARAM_CONTEXT:
1041                                         case VMSG_PARAM_LANGUAGE:
1042                                                 // prevent 7605 08.03.13
1043                                                 szValue = __VMsgGetParamVal( pMsgRaw, &status, &dLen );
1044                                                 numberedParam = 0;
1045                                                 break;
1046                                         default:
1047                                                 szValue = __VMsgGetParamVal( pMsgRaw, &status, &dLen );
1048
1049                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgTypeList, VMSG_TYPE_PARAM_NUM, pTmpParam, VMSG_PARAM_TYPE, enc);
1050                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgValueList, VMSG_VALUE_PARAM_NUM, pTmpParam, VMSG_PARAM_VALUE, enc);
1051                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgEncList, VMSG_ENCODE_PARAM_NUM, pTmpParam, VMSG_PARAM_ENCODING, enc);
1052                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgCharsetList, VMSG_CHARSET_PARAM_NUM, pTmpParam, VMSG_PARAM_CHARSET, enc);
1053
1054                                                 numberedParam = 0;
1055                                                 pMsgRaw += dLen;
1056                                                 dLen = 0;
1057
1058                                                 break;
1059                                 }
1060
1061                                 VDATA_TRACE("%d, %s, %p",numberedParam, szValue, pTmpParam);
1062                                 pTmpParam->paramValue = numberedParam;
1063                                 pTmpParam->pNext = NULL;
1064                                 VFREE(szValue);
1065                                 pMsgRaw += dLen;
1066                                 break;
1067                         case VMSG_TYPE_VALUE_STATUS:
1068                                 dLen = 0;
1069                                 temp = __VMsgGetTypeVal( pMsgRaw, &status, &dLen, enc, pCurrent->pCur);
1070
1071                                 if(valueCount <= VDATA_VALUE_COUNT_MAX) {
1072                                         pCurrent->pCur->pszValue[valueCount] = temp;
1073                                         valueCount++;
1074                                         pCurrent->pCur->valueCount = valueCount;
1075                                         VDATA_TRACE("object property: %d, value: %s", pCurrent->pCur->property, pCurrent->pCur->pszValue[valueCount - 1]);
1076                                 }
1077                                 else
1078                                         VFREE(temp);
1079
1080                                 pMsgRaw += dLen;
1081                                 break;
1082                 }
1083         }
1084         VDATA_TRACE("pMsgRawTmp: %s", pMsgRawTmp);
1085         //VFREE(pMsgRawTmp);
1086
1087         if(pVMsg->pTop == NULL)
1088         {
1089                 VDATA_TRACE("pVMsg->Top: NULL");
1090                 goto CATCH;
1091         }
1092
1093         if(!vmsg_ended) {
1094                 VDATA_TRACE("vmsg_ended: false");
1095                 goto CATCH1;
1096         }
1097         VDATA_TRACE_END
1098         return pVMsg;
1099
1100 CATCH :
1101         VFREE(pTemp);
1102 CATCH1 :
1103         VFREE(pMsgRawTmp);
1104         __VMsgFreeVTreeMemory(pVMsg);
1105         VDATA_TRACE_END
1106         return NULL;
1107 }
1108
1109 /*
1110  * vmsg_encode() compares the string and vMsg type, parameter value.
1111  *
1112  * @param       pVMsgRaw            Data which will be encoded
1113  * @return      char *              Encoded result
1114  */
1115 SLPAPI char*
1116 vmsg_encode( VTree *pVMsgRaw )
1117 {
1118         VDATA_TRACE_BEGINE
1119         char*           pVMsgRes = NULL;
1120         char*           pTmpVMsgRes = NULL;
1121         VTree*          pTmpTree = NULL;
1122         VObject *       pTmpObj =  NULL;
1123         char*           pTemp = NULL;
1124         int                     len;
1125         int                     total = 0;
1126         int             cnt = 0;
1127
1128         for(;cnt < pVMsgRaw->pTop->valueCount;cnt++) {
1129
1130                 if(pVMsgRaw->pTop->pszValue[cnt] == NULL)  {
1131                         VDATA_TRACE("pVMsgRaw->pTop->valueCount : %d",pVMsgRaw->pTop->valueCount);
1132                         VDATA_TRACE("pVMsgRaw->pTop->pszValue[%d] : %s", cnt, pVMsgRaw->pTop->pszValue[cnt]);
1133                         VDATA_TRACE_END
1134                         return NULL;
1135                 }
1136         }
1137
1138         pTmpTree = pVMsgRaw;
1139         pTmpObj = pVMsgRaw->pTop;
1140
1141         while(true)
1142         {
1143                 switch(pTmpTree->treeType)
1144                 {
1145                         case VMESSAGE:
1146                                 if (pVMsgRes) {
1147                                         free(pVMsgRes);
1148                                         pVMsgRes = NULL;
1149                                 }
1150
1151                                 if ( ( pVMsgRes = ( char * )malloc( sizeof( char ) * ( total += 13 ) ) ) == NULL )
1152                                 {
1153                                         VDATA_TRACE(  "vmsg_encode:malloc failed\n" );
1154                                         VDATA_TRACE_END
1155                                         return NULL;
1156                                 }
1157                                 memcpy( pVMsgRes, "BEGIN:VMSG\r\n", 13 );
1158                                 break;
1159
1160                         case VBODY:
1161                                 if ( ( pTmpVMsgRes = ( char * )realloc( pVMsgRes,  sizeof( char ) * ( total += 14 ) ) ) == NULL )
1162                                 {
1163                                         VDATA_TRACE(  "vmsg_encode:realloc failed\n" );
1164                                         VFREE(pVMsgRes);
1165                                         VDATA_TRACE_END
1166                                         return NULL;
1167                                 }
1168
1169                                 pVMsgRes = pTmpVMsgRes;
1170                                 strncat( pVMsgRes, "BEGIN:VBODY\r\n", 13);
1171                                 break;
1172
1173                         case VCARD:
1174                                 break;
1175                 }
1176
1177                 while ( true )
1178                 {
1179                         if(pTmpObj == NULL)
1180                                 break;
1181
1182                         if ( ( pTemp = __VMsgTypeEncode( pTmpObj, pTmpObj->property == VCARD_TYPE_TEL ? "TEL" : pszMsgTypeList[pTmpObj->property] ) ) != NULL )
1183                         {
1184                                 if(pTmpTree->treeType == VCARD)
1185                                 {
1186                                         char* encoded  = NULL;
1187
1188                                         encoded = vcard_encode(pTmpTree);
1189                                         if (encoded == NULL) {
1190                                                 VDATA_TRACE(  "vcard_encode() failed\n");
1191                                                 VFREE(pTemp);
1192                                                 VFREE(pVMsgRes);
1193                                                 VDATA_TRACE_END
1194                                                 return NULL;
1195                                         }
1196
1197                                         len= strlen(encoded);
1198
1199                                         if ( ( pTmpVMsgRes = ( char* )realloc( pVMsgRes, ( total += len+10 ) ) ) == NULL )
1200                                         {
1201                                                 VDATA_TRACE(  "vmsg_encode():realloc failed\n");
1202                                                 VFREE( pTemp );
1203                                                 VFREE( encoded );
1204                                                 VFREE(pVMsgRes);
1205                                                 VDATA_TRACE_END
1206                                                 return NULL;
1207                                         }
1208
1209                                         pVMsgRes = pTmpVMsgRes;
1210                                         strncat(pVMsgRes, encoded, len+10);
1211                                         VDATA_TRACE("pTemp : %s", encoded);
1212                                         VFREE( pTemp );
1213                                         VFREE( encoded );
1214                                         VFREE(pVMsgRes);
1215                                         break;
1216                                 }
1217                                 else
1218                                 {
1219                                         len = strlen( pTemp );
1220
1221                                         if ( ( pTmpVMsgRes = ( char* )realloc( pVMsgRes, ( total += len+10 ) ) ) == NULL )
1222                                         {
1223                                                 VDATA_TRACE(  "vmsg_encode():realloc failed\n");
1224                                                 VFREE( pTemp );
1225                                                 VFREE(pVMsgRes);
1226                                                 VDATA_TRACE_END
1227                                                 return NULL;
1228                                         }
1229                                         pVMsgRes = pTmpVMsgRes;
1230                                         strncat(pVMsgRes, pTemp, len+10);
1231                                         VDATA_TRACE("pTemp : %s", pTemp);
1232                                         VFREE( pTemp );
1233
1234                                         if ( pTmpObj->pSibling != NULL )
1235                                                 pTmpObj = pTmpObj->pSibling;
1236                                         else
1237                                                 break;
1238                                 }
1239                         }
1240
1241
1242                 }
1243
1244                 switch(pTmpTree->treeType)
1245                 {
1246                         case VBODY:
1247                                 if ( ( pTmpVMsgRes = ( char * )realloc( pVMsgRes, ( total += 12 ) ) ) == NULL )
1248                                 {
1249                                         VFREE(pVMsgRes);
1250                                         VDATA_TRACE(  "vcal_encode():realloc failed\n");
1251                                         return NULL;
1252                                 }
1253
1254                                 pVMsgRes = pTmpVMsgRes;
1255                                 strncat( pVMsgRes, "END:VBODY\r\n", 12);
1256                                 break;
1257
1258                         case VCARD:
1259                                 break;
1260
1261                         case VMESSAGE:
1262                                 break;
1263
1264                 }
1265
1266                 if ( pTmpTree->pNext != NULL )
1267                         pTmpTree = pTmpTree->pNext;
1268                 else
1269                         break;
1270                 pTmpObj = pTmpTree->pTop;
1271         }
1272
1273         if ( ( pTmpVMsgRes = ( char * )realloc( pVMsgRes, ( total += 11 ) ) ) == NULL )
1274         {
1275                 VDATA_TRACE(  "vmsg_encode:realloc failed\n");
1276                 VFREE(pVMsgRes);
1277                 VDATA_TRACE_END
1278                 return NULL;
1279         }
1280
1281         pVMsgRes = pTmpVMsgRes;
1282         strncat( pVMsgRes, "END:VMSG\r\n", 11);
1283         VDATA_TRACE_END
1284         return pVMsgRes;
1285 }
1286
1287
1288 /*
1289  * VIsVmsgFile() verify VMsg file.
1290  *
1291  * @param       pVMsgRaw           Data which will be encoded
1292  * @return      int                 result (true or false)
1293  */
1294 int
1295 __VIsVmsgFile(char *pMsgRaw, int mode)
1296 {
1297         int i=0;
1298         bool rtnValue = true;
1299         char *pszVmsgBegin = "BEGIN:VMSG";
1300
1301         switch(mode)
1302         {
1303                 case CHECK_START :
1304                         for(i=0; i < 10; i++)
1305                 if(*pszVmsgBegin++ != *pMsgRaw++)
1306                                         rtnValue = false;
1307                         break;
1308
1309                 default :
1310                         rtnValue = false;
1311         }
1312         VDATA_TRACE_END
1313         return rtnValue;
1314 }
1315
1316
1317 /*
1318  * vMsgTypeEncoder() compares the string and vMsg type, parameter value.
1319  *
1320  * @param               typeObj                         Data which will be encoded
1321  * @param               type                            Name of the type
1322  * @return      char *              Encoded result
1323  */
1324 char*
1325 __VMsgTypeEncode( VObject *pTypeObj, char *pType )
1326 {
1327         VDATA_TRACE_BEGINE
1328         int                     len;
1329         char*           pTemp = NULL;
1330         char*           szTypeValue = NULL;
1331         int                     i;
1332         int                     enc = 0;
1333         char*           pEncode = NULL;
1334         char*           pRes = NULL;
1335         int                     total = 0;
1336         int                     biLen = 0;
1337
1338         len = strlen( pType );
1339         biLen = pTypeObj->numOfBiData;
1340
1341         if ( ( szTypeValue = ( char * )malloc( total += ( len+1 ) ) ) == NULL )
1342         {
1343                 VDATA_TRACE(  "__VMsgTypeEncode():malloc failed\n");
1344                 VDATA_TRACE_END
1345                 return NULL;
1346         }
1347         memset( szTypeValue, '\0', ( len+1 ) );
1348         strncat( szTypeValue, pType, len+1);
1349
1350         pTemp = __VMsgParamEncode( pTypeObj, &enc );
1351         if ( pTemp != NULL )
1352         {
1353                 len = strlen( pTemp );
1354                 if ( ( szTypeValue = ( char * )realloc( szTypeValue, ( total += len ) ) ) == NULL )
1355                 {
1356                         VDATA_TRACE(  "__VMsgTypeEncode():realloc failed\n");
1357                         VFREE( pTemp );
1358                         pTemp = NULL
1359                         VDATA_TRACE_END;
1360                         return NULL;
1361                 }
1362                 strncat( szTypeValue, pTemp, len);
1363                 VFREE( pTemp );
1364                 pTemp = NULL;
1365         }
1366
1367         if ( ( szTypeValue = ( char * )realloc( szTypeValue, ( total += 2 ) ) ) == NULL )
1368         {
1369                 VDATA_TRACE_END
1370                 return NULL;
1371         }
1372
1373         strncat( szTypeValue, ":", 2 );
1374
1375         len = 0;
1376
1377         if(strcmp(pType, pszMsgTypeList[6]) != 0)       {
1378                 for ( i = 0; i < pTypeObj->valueCount; i++ ) {
1379
1380                         if(pTypeObj->pszValue[i] != NULL)
1381                         len += strlen( pTypeObj->pszValue[i] );
1382                 }
1383         }
1384         else
1385                 len += biLen;
1386
1387
1388         for ( i = 0; i < pTypeObj->valueCount; i++ ) {
1389
1390                 if ( i == 0 )
1391                 {
1392                         if ( ( pEncode = ( char * )malloc( len+20 ) ) == NULL )
1393                         {
1394                                 VFREE(szTypeValue);
1395                                 VDATA_TRACE_END
1396                                 return NULL;
1397                         }
1398
1399                         memset( pEncode, '\0', len+20 );
1400
1401                         if(strcmp(pType, pszMsgTypeList[6]) != 0)
1402                         {
1403                                 strncat( pEncode, pTypeObj->pszValue[i], 20 );
1404                                 _VEscape(pEncode);
1405                         }
1406                         else
1407                                 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1408                 }
1409                 else
1410                 {
1411                         char    buf[1000];
1412                         strncpy( buf, pTypeObj->pszValue[i], 999 );
1413                         _VEscape( buf );
1414                         strcat( pEncode, ";" );
1415                         strcat( pEncode, buf );
1416                 }
1417         }
1418
1419         if(strcmp(pType, pszMsgTypeList[6]) != 0)       {
1420                 if (pEncode) {
1421                         strcat( pEncode, "\0\0" );
1422                         len = strlen( pEncode );
1423                 }
1424         }
1425         else {
1426                 len = biLen;
1427         }
1428
1429         if ( enc & pMsgEncList[2].flag ) {
1430                 if((pRes = (char *)malloc(len * 6 + 10)) == NULL) {
1431                         VFREE(pEncode);
1432                         VFREE(szTypeValue);
1433                         VDATA_TRACE_END
1434                         return NULL;
1435                 }
1436                 if(pEncode)
1437                         _VQPEncode( pRes, pEncode );
1438                 VFREE(pEncode);
1439                         }
1440         else if(enc & pMsgEncList[1].flag )
1441         {
1442                 if((pRes = (char *)malloc((len * 8 / 6) + 48)) == NULL)
1443                 {
1444                         VFREE(pEncode);
1445                         VFREE(szTypeValue);
1446                         VDATA_TRACE_END
1447                         return NULL;
1448                 }
1449
1450                 memset( pRes, '\0', ( ( len * 8 / 6 ) + 48 ) );
1451                 _VB64Encode( pRes, pEncode, biLen );
1452                 VDATA_TRACE(  "Origin Size: %d, Allocated Size %d, Coverted Size: %d\n", biLen, ( len * 8 / 6 ) + 48, strlen(pRes));
1453                 VFREE(pEncode);
1454         }
1455         else
1456         {
1457                 if((pRes = (char *)malloc(len+30)) == NULL)
1458                 {
1459                         VFREE(pEncode);
1460                         VFREE(szTypeValue);
1461                         VDATA_TRACE_END
1462                         return NULL;
1463                 }
1464                 memset( pRes, '\0', ( len + 30 ) );
1465                 if(pEncode)
1466                 {
1467                         memcpy( pRes, pEncode, len );
1468                         VFREE(pEncode);
1469                 }
1470         }
1471
1472         if((pRes = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL)
1473         {
1474                 VFREE(pEncode);
1475                 VFREE(szTypeValue);
1476                 VDATA_TRACE_END
1477                 return NULL;
1478         }
1479         strncat( pRes, "\r\n", strlen(pRes) + 2);
1480
1481         len = strlen( pRes );
1482
1483         if ((szTypeValue = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1484                 VFREE(pEncode);
1485                 VFREE(pRes);
1486                 VDATA_TRACE_END
1487                 return NULL;
1488         }
1489
1490         strncat(szTypeValue, pRes, total - 1);
1491
1492         if(strcmp(pType, pszMsgTypeList[6]) != 0) {
1493                 _VRLSpace( szTypeValue );
1494                 _VRTSpace( szTypeValue );
1495         }
1496
1497         VFREE(pRes);
1498
1499         VDATA_TRACE_END
1500         return szTypeValue;
1501 }
1502
1503 /**
1504  * __VMsgParamEncode() Parameter Encoding.
1505  *
1506  * @param               pTypeObj                Data which will be encoded
1507  * @param               pEnc                            Name of the type
1508  */
1509 char *
1510 __VMsgParamEncode(VObject* pTypeObj, int* pEnc)
1511 {
1512         VDATA_TRACE_BEGINE
1513         int i = 0;
1514         int len = 0;
1515         int sNum = 0;
1516         int shift = 0;
1517         bool bSupported;
1518         char* szParam = NULL;
1519         VParam* pTemp = NULL;
1520         ValueObj*       pList = NULL;
1521
1522         /** Paramter initialize. */
1523         pTemp = pTypeObj->pParam;
1524
1525         /** Momory Allocation for parameter string. */
1526         if(pTemp != NULL) {
1527                 if ((szParam = (char*)malloc(len+=2)) == NULL)
1528                 {
1529                         VDATA_TRACE_END
1530                         return NULL;
1531                 }
1532                 memset(szParam, 0x00, 2);
1533         }
1534
1535         /** appending pamaters. */
1536         while(true) {
1537
1538                 if(pTemp == NULL) break;
1539
1540                 bSupported = false;
1541
1542                 /** Expand szParam string. For appending.*/
1543                 if((szParam = (char *)realloc(szParam, len += 15)) == NULL)
1544                 {
1545                         VDATA_TRACE_END
1546                         return NULL;
1547                 }
1548
1549                 /** appending paramter name. */
1550                 strcat( szParam, ";" );
1551                 if(pTemp->parameter != VMSG_PARAM_TYPE) {
1552                         strcat( szParam, pszMsgParamList[pTemp->parameter] );
1553                         strcat( szParam, "=" );
1554                 }
1555
1556                 /** Set Parameter Value name. */
1557                 switch ( pTemp->parameter )
1558                 {
1559                         case VMSG_PARAM_ENCODING:
1560                                 *pEnc = pMsgEncList[pTemp->paramValue].flag;
1561                                 shift = VMSG_ENCODE_PARAM_NUM;
1562                                 pList = pMsgEncList; bSupported = true;
1563                                 break;
1564                         case VMSG_PARAM_TYPE:
1565                                 shift = VMSG_TYPE_PARAM_NUM;
1566                                 pList = pMsgTypeList; bSupported = true;
1567                                 break;
1568                         case VMSG_PARAM_VALUE:
1569                                 shift = VMSG_VALUE_PARAM_NUM;
1570                                 pList = pMsgValueList; bSupported = true;
1571                                 break;
1572                         case VMSG_PARAM_CHARSET:
1573                                 shift = VMSG_CHARSET_PARAM_NUM;
1574                                 pList = pMsgCharsetList; bSupported = true;
1575                                 break;
1576                         default:
1577                                 if ( ( szParam = ( char* )realloc( szParam, 5 ) ) == NULL )
1578                                 {
1579                                         VDATA_TRACE_END
1580                                         return NULL;
1581                                 }
1582                                 strcat( szParam, "NONE" );
1583                 }
1584
1585                 /** exchage parameter value's to string.*/
1586                 if(bSupported == true) {
1587
1588                         for(i = 0, sNum = 0x00000001; i < shift; i++) {
1589
1590                                 if(pList[pTemp->paramValue].flag & sNum) {
1591                                         if((szParam = (char *)realloc(szParam, ( len += (strlen(pList[i].szName) + 2)))) == NULL)
1592                                         {
1593                                                 VDATA_TRACE_END
1594                                                 return NULL;
1595                                         }
1596
1597                                         strcat( szParam, pList[i].szName );
1598                                         strcat( szParam, "; " );
1599                                 }
1600
1601                                 sNum <<= 1;
1602                         }
1603                 }
1604
1605                 /** remove semicolon from tail. */
1606                 for(i = strlen( szParam ); i > 0 ; i--) {
1607
1608                         if ( szParam[i] == ' ' && szParam[i-1] == ';' ) {
1609                                 szParam[i-1] = '\0';
1610                                 break;
1611                         }
1612                 }
1613
1614                 if ( pTemp->pNext != NULL )
1615                         pTemp = pTemp->pNext;
1616                 else
1617                         break;
1618         }
1619         VDATA_TRACE_END
1620         return szParam;
1621 }
1622
1623 SLPAPI bool
1624 vmsg_free_vtree_memory(VTree * pTree)
1625 {
1626         VDATA_TRACE_BEGINE
1627         if(pTree == NULL)
1628         {
1629                 VDATA_TRACE_END
1630                 return false;
1631         }
1632         VDATA_TRACE_END
1633         return __VMsgFreeVTreeMemory(pTree);
1634 }