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