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