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