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                         }
 375                         *pStatus = VMSG_PARAM_VALUE_STATUS;
 376                         break;
 377                 }
 378                 /**
 379                  * This case, There is no parameter type. Only Parameter Value.
 380                  * In VMSG_PARAM_NAME_STATUS status, VTYPE_TOKEN_COLON means that anything parameter is no more.
 381                  * so set next step to VMSG_PARAM_VALUE_STATUS.
 382                  *
 383                  * Ex) TEL;WORK:+12341234
 384                  *        ------ ":" next is TEL TYPE's value.
 385                  *
 386                  * VMSG_PARAM_NAME_STATUS(current) -> VMSG_PARAM_VALUE_STATUS
 387                  * -> VMSG_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
 388                  */
 389                 else if (c == VTYPE_TOKEN_COLON) {
 390                         *pStatus = VMSG_PARAM_VALUE_STATUS;
 391                         pVMsgRaw = pTemp;
 392                         (*pDLen) = 0;
 393                         res = UNKNOWN_NAME;
 394                         break;
 395                 }
 396                 /**
 397                  * This case, There is no parameter type. Only Parameter Value.
 398                  * In VMSG_PARAM_NAME_STATUS status, VTYPE_TOKEN_SEMICOLON means that there is a next parameter.
 399                  * so set next step to VMSG_PARAM_NAME_STATUS.
 400                  *
 401                  * Ex) TEL;WORK;PREF:+12341234
 402                  *        ------ ":" next is TEL TYPE's value.
 403                  *
 404                  * VMSG_PARAM_NAME_STATUS(current) -> VMSG_PARAM_NAME_STATUS
 405                  * -> VMSG_PARAM_VALUE_STATUS -> VMSG_TYPE_VALUE_STATUS -> MOVE TO NEXT TYPE
 406                  */
 407                 else if (c == VTYPE_TOKEN_SEMICOLON) {
 408                         *pStatus = VMSG_PARAM_NAME_STATUS;
 409                         pVMsgRaw = pTemp;
 410                         (*pDLen) = 0;
 411                         res = UNKNOWN_NAME;
 412                         break;
 413                 } else if ((c == '\r') || (c == '\n') || (_VIsSpace(c))) {
 414
 415                 } else
 416                         name[index++] = c;
 417         }
 418         VDATA_TRACE_END
 419         return res;
 420 }
 421
 422 bool
 423 __VMsgFreeVTreeMemory(VTree * pTree)
 424 {
 425         VDATA_TRACE_BEGINE
 426         VObject*                pCurObj = NULL;
 427         VObject*                pNextObj = NULL;
 428
 429         VTree*                  pCurTree = NULL;
 430         VTree*                  pNextTree = NULL;
 431
 432         VParam* pCurParam = NULL;
 433         VParam* pNextParam = NULL;
 434
 435         int count = 0;
 436         int i = 0;
 437
 438         SysRequireEx(pTree->treeType == VMESSAGE, false);
 439         SysRequireEx(pTree != NULL, false);
 440         VDATA_TRACE("vmsg_free_vtree_memory() entered.");
 441
 442         if (pTree->treeType != VMESSAGE) {
 443                 VDATA_TRACE_END
 444                 return true;
 445         }
 446
 447         pCurTree = pTree;
 448
 449         while (pCurTree) {
 450                 pNextTree = pCurTree->pNext;
 451                 pCurObj = pCurTree->pTop;
 452
 453                 while (pCurObj) {
 454
 455                         pNextObj = pCurObj->pSibling;
 456                         count = pCurObj->valueCount;
 457
 458                         for (i = 0; i < count; i++) {
 459                                 VFREE(pCurObj->pszValue[i]);
 460                         }
 461
 462                         if (pCurObj->pParam) {
 463
 464                                 pCurParam = pCurObj->pParam;
 465
 466                                 while (pCurParam != NULL) {
 467                                         pNextParam = pCurParam->pNext;
 468                                         VDATA_TRACE("pNEXT ==> %p", pCurParam->pNext);
 469                                         VDATA_TRACE("pPARAM ==> %p", pCurParam->parameter);
 470                                         VDATA_TRACE("pVALUE ==> %p", pCurParam->paramValue);
 471                                         VDATA_TRACE("pCurParam : %p", pCurParam);
 472                                         VDATA_TRACE("pCurParam->parameter : %d", pCurParam->parameter);
 473                                         VDATA_TRACE("pCurParam->paramValue : %d", pCurParam->paramValue);
 474                                         if (pNextParam != NULL) {
 475                                                 VDATA_TRACE("pNextParam : %p", pNextParam);
 476                                                 VDATA_TRACE("pNextParam->parameter : %d", pNextParam->parameter);
 477                                                 VDATA_TRACE("pNextParam->paramValue : %d", pNextParam->paramValue);
 478                                         }
 479                                         VFREE(pCurParam);
 480                                         pCurParam = pNextParam;
 481                                 }
 482                         }
 483
 484                         VFREE(pCurObj);
 485                         pCurObj = pNextObj;
 486                 }
 487
 488                 VFREE(pCurTree);
 489                 pCurTree = pNextTree;
 490         }
 491
 492         VDATA_TRACE("exit vmsg_free_vtree_memory");
 493         VDATA_TRACE_END
 494         return true;
 495 }
 496
 497 /**
 498  * __VMsgGetParamVal() fine the param value and returns value.
 499  *
 500  * @param               pVMsgRaw        The raw data
 501  * @param               pStatus         Decoder status
 502  * @param               pDLen           retrived length
 503  *
 504  * @return      buffer          The result value
 505  */
 506 char*
 507 __VMsgGetParamVal(char* pVMsgRaw, int* pStatus, int* pDLen)
 508 {
 509         VDATA_TRACE_BEGINE
 510         int len = 0;
 511         char    c;
 512         char* pBuf = NULL;
 513         char* pTemp = pVMsgRaw;
 514
 515         SysRequireEx(pVMsgRaw, NULL);
 516
 517         while (true) {
 518                 GO_NEXT_CHAR(c, pVMsgRaw, pDLen);
 519                 len++;
 520                 switch (c) {
 521                         case VTYPE_TOKEN_SEMICOLON:
 522                                 *pStatus = VMSG_PARAM_NAME_STATUS;
 523                                 break;
 524                         case VTYPE_TOKEN_COLON:
 525                                 *pStatus = VMSG_TYPE_VALUE_STATUS;
 526                                 break;
 527                         case VTYPE_TOKEN_COMMA:
 528                                 *pStatus = VMSG_PARAM_VALUE_STATUS;
 529                                 break;
 530                 }
 531                 if (c == VTYPE_TOKEN_SEMICOLON
 532                                 || c == VTYPE_TOKEN_COLON
 533                                 || c == VTYPE_TOKEN_COMMA
 534                                 || c == 0x00)
 535                         break;
 536         }
 537
 538         if (len < 1 || (pBuf = (char *)calloc(1, len)) == NULL)
 539                 return NULL;
 540         memset(pBuf, 0x00, len);
 541         memcpy(pBuf, pTemp, len-1);
 542         TRIM(pBuf);
 543         VDATA_TRACE_END
 544         return pBuf;
 545 }
 546
 547
 548 /**
 549  * __VMsgGetTypeVal() fine the type value and returns value.
 550  *
 551  * @param       pVMsgRaw        The raw data
 552  * @param               status                  Decoder status
 553  * @return      buffer          The result value
 554  */
 555 char*
 556 __VMsgGetTypeVal(char* pVMsgRaw, int* pStatus, int* pDLen, int enc, VObject* pType)
 557 {
 558         VDATA_TRACE_BEGINE
 559         int num = 0;
 560         int len = 0;
 561         int bufferCount = 0;
 562
 563         bool bEscape = false;
 564
 565         char    c, c1, c2;
 566         char* pBuf = NULL;
 567         char* pTemp = pVMsgRaw;
 568         char* pTmpBuf = NULL;
 569         int Status = 0;
 570         int Len = 0;
 571
 572         SysRequireEx(pVMsgRaw, NULL);
 573         VDATA_TRACE("pVMsgRaw: %s", pVMsgRaw);
 574         while (true) {
 575                 GO_NEXT_CHAR(c, pVMsgRaw, pDLen);
 576
 577                 if (c == 0x00)
 578                         break;
 579
 580                 len++;
 581
 582                 /** This case means that there are more type's value. */
 583                 if (c == VTYPE_TOKEN_SEMICOLON && bEscape == false) {
 584                         if ((pBuf = (char *)calloc(1, len)) == NULL)
 585                                 return NULL;
 586
 587                         memset(pBuf, 0x00, len);
 588                         memcpy(pBuf, pTemp, len-1);
 589
 590                         TRIM(pBuf);
 591                         _VUnescape(pBuf);
 592
 593                         *pStatus = VMSG_TYPE_VALUE_STATUS;
 594
 595                         /** Base 64 Decoding */
 596                         if ((enc & pMsgEncList[1].flag) || (enc & pMsgEncList[0].flag)) {
 597
 598                                 bufferCount = (len * 6 / 8) + 2;
 599
 600                                 if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
 601                                         VFREE(pBuf);
 602                                         return NULL;
 603                                 }
 604
 605                                 memset(pTmpBuf, 0x00, bufferCount);
 606                                 num = _VB64Decode(pTmpBuf, pBuf);
 607
 608                                 if (pType != NULL)
 609                                         pType->numOfBiData = num;
 610
 611                                 VFREE(pBuf);
 612                                 pBuf = pTmpBuf;
 613                                 pTmpBuf = NULL;
 614                                 break;
 615                         }
 616
 617                         /** Quoted Printable Decoding */
 618                         if (enc & pMsgEncList[2].flag) {
 619
 620                                 int i = 0, j = 0;
 621
 622                                 while (pBuf[i]) {
 623                                         if (pBuf[i] == '\n' || pBuf[i] == '\r') {
 624                                                 i++;
 625                                                 if (pBuf[i] == '\n' || pBuf[i] == '\r')
 626                                                         i++;
 627
 628                                                 if (pBuf[j-1] == '=')
 629                                                         j--;
 630                                         } else
 631                                                 pBuf[j++] = pBuf[i++];
 632                                 }
 633                                 pBuf[j] = '\0';
 634
 635                                 _VQPDecode(pBuf);
 636                                 TRIM(pBuf);
 637                                 break;
 638                         }
 639                         break;
 640                 }
 641
 642                 if (c == '\\')
 643                         bEscape = true;
 644                 else if (bEscape == true && c != VTYPE_TOKEN_SEMICOLON)
 645                         bEscape = false;
 646                 else if ((c == '\r') || (c == '\n')) {
 647                         c2 = *(pVMsgRaw-2);
 648
 649                         if (c2 == '=' && (enc & pMsgEncList[2].flag)) {
 650                                 c1 = *pVMsgRaw;
 651                                 if ((c1 == '\r') || (c1 == '\n')) {
 652                                         pVMsgRaw += 1;
 653                                         (*pDLen) += 1;
 654                                         len++;
 655                                 }
 656                         } else if (__VMsgGetTypeName(pVMsgRaw, &Status, &Len) != UNKNOWN_NAME) {
 657                                 if ((pBuf = (char *)calloc(1, len)) == NULL)
 658                                         return NULL;
 659
 660                                 memset(pBuf, 0x00, len);
 661                                 memcpy(pBuf, pTemp, len-1);
 662
 663                                 TRIM(pBuf);
 664                                 _VUnescape(pBuf);
 665                                 VDATA_TRACE("pVMsgRaw: %s", pVMsgRaw);
 666                                 *pStatus = VMSG_TYPE_NAME_STATUS;
 667
 668                                 c1 = *pVMsgRaw;
 669
 670                                 if ((c1 == '\r') || (c1 == '\n')) {
 671                                         pVMsgRaw += 1;
 672                                         (*pDLen) += 1;
 673                                 }
 674
 675                                 if ((enc & pMsgEncList[1].flag) || (enc & pMsgEncList[0].flag)) {
 676
 677                                         bufferCount = (len * 6 / 8) + 5;
 678
 679                                         if ((pTmpBuf = (char *)calloc(1, bufferCount)) == NULL) {
 680                                                 VFREE(pBuf);
 681                                                 return NULL;
 682                                         }
 683
 684                                         memset(pTmpBuf, 0x00, bufferCount);
 685                                         num = _VB64Decode(pTmpBuf, pBuf);
 686
 687                                         if (pType != NULL)
 688                                                 pType->numOfBiData = num;
 689
 690                                         VFREE(pBuf);
 691                                         pBuf = pTmpBuf;
 692                                         pTmpBuf = NULL;
 693                                         break;
 694                                 }
 695
 696                                 if (enc & pMsgEncList[2].flag) {
 697
 698                                         int i = 0, j = 0;
 699
 700                                         while (pBuf[i]) {
 701                                                 if (pBuf[i] == '\n' || pBuf[i] == '\r') {
 702                                                         i++;
 703                                                         if (pBuf[i] == '\n' || pBuf[i] == '\r')
 704                                                                 i++;
 705
 706                                                         if (pBuf[j-1] == '=') j--;
 707                                                 } else
 708                                                         pBuf[j++] = pBuf[i++];
 709                                         }
 710                                         pBuf[j] = '\0';
 711
 712                                         _VQPDecode(pBuf);
 713                                         TRIM(pBuf);
 714                                         break;
 715                                 }
 716                                 break;
 717                         }
 718                 }
 719         }
 720
 721         VDATA_TRACE_END
 722         return pBuf;
 723 }
 724
 725
 726 int
 727 VMsgGetTypeValue(int index)
 728 {
 729         VDATA_TRACE_BEGINE
 730         VDATA_TRACE("VMsgGetTypeValue() enter..\n");
 731         VDATA_TRACE_END
 732         return pMsgTypeList[index].flag;
 733 }
 734
 735 int
 736 VMsgGetValValue(int index)
 737 {
 738         VDATA_TRACE_BEGINE
 739         VDATA_TRACE("VMsgGetValValue() enter..\n");
 740         VDATA_TRACE_END
 741         return pMsgValueList[index].flag;
 742 }
 743
 744 int
 745 VMsgGetEncValue(int index)
 746 {
 747         VDATA_TRACE_BEGINE
 748         VDATA_TRACE("VMsgGetEncValue() enter..\n");
 749         VDATA_TRACE_END
 750         return pMsgEncList[index].flag;
 751 }
 752
 753 int
 754 VMsgGetCharsetValue(int index)
 755 {
 756         VDATA_TRACE_BEGINE
 757         VDATA_TRACE("VMsgGetCharsetValue() enter..\n");
 758         VDATA_TRACE_END
 759         return pMsgCharsetList[index].flag;
 760 }
 761
 762 /*
 763  * vmsg_decode() decode the vMsg data and returns vObject struct
 764  *
 765  * @param       pVMsgRaw            The raw data
 766  * @return      vObject             The result value
 767  */
 768 VTree* vmsg_decode(char *pMsgRaw)
 769 {
 770         VDATA_TRACE_BEGINE;
 771
 772         char* szValue = NULL;
 773         char* szMsgBegin = NULL;
 774         char* pMsgRawTmp = NULL;
 775         VTree* pVMsg = NULL;
 776         VTree* pVBody = NULL;
 777         VTree* pCurrent = NULL;
 778         VTree* pVCard = NULL;
 779         VParam* pTmpParam = NULL;
 780         VObject* pTemp = NULL;
 781
 782         char    c;
 783
 784         int type, param;
 785         int status = VMSG_TYPE_NAME_STATUS;
 786         int done = false;
 787         int valueCount = 0;
 788         int len;
 789         int dLen = 0;
 790         int param_status = false;
 791         int numberedParam = 0;
 792         int enc = 0;
 793         int start_status = 0;
 794         char* temp = NULL;
 795         char* pVTree = NULL;
 796         bool vmsg_ended = false;
 797
 798         SysRequireEx(pMsgRaw != NULL, NULL);
 799         len = strlen(pMsgRaw);
 800         VDATA_TRACE("length of pCardRaw = %d", len);
 801
 802         len = _VUnfoldingNoSpec(pMsgRaw, VMESSAGE);
 803         pMsgRawTmp = pMsgRaw;
 804         len = _VManySpace2Space(pMsgRaw);
 805
 806         VDATA_TRACE("ret value of _VManySpace2Space = %d", len);
 807
 808         if (!__VIsVmsgFile(pMsgRaw, CHECK_START)) {
 809                 VFREE(pMsgRawTmp);
 810                 VDATA_TRACE_END
 811                 return NULL;
 812         }
 813
 814         while (true && !done) {
 815                 c = *pMsgRaw;
 816
 817                 if ((c == '\0') || done)
 818                         break;
 819
 820                 switch (status) {
 821                         case VMSG_TYPE_NAME_STATUS:
 822                                 dLen = 0;
 823                                 type = __VMsgGetTypeName(pMsgRaw, &status, &dLen);
 824
 825                                 if (type == VMSG_TYPE_BEGIN)
 826                                         pVTree = pMsgRaw;
 827
 828                                 pMsgRaw += dLen;
 829
 830                                 if (type == -1)
 831                                         break;
 832
 833                                 switch (type) {
 834                                         case VMSG_TYPE_BEGIN:
 835                                                 dLen = 0;
 836                                                 enc = 0;
 837                                                 szMsgBegin = __VMsgGetTypeVal(pMsgRaw, &status, &dLen, enc, NULL);
 838                                                 pMsgRaw += dLen;
 839
 840                                                 if (szMsgBegin == NULL)
 841                                                         goto CATCH;
 842
 843                                                 if (!strncmp(szMsgBegin, "VCARD", strlen("VCARD"))) {
 844                                                         VDATA_TRACE("pVTree: %s", pVTree);
 845                                                         pVCard = vcard_decode(pVTree);
 846                                                         pCurrent->pNext = pVCard;
 847                                                         pCurrent = pVCard;
 848
 849                                                         dLen = ((strstr(pMsgRaw, "END:VCARD") + 9) - pMsgRaw);
 850                                                         pMsgRaw += dLen;
 851                                                 } else {
 852
 853                                                         if (start_status == 1)
 854                                                                 goto CATCH;
 855
 856
 857                                                         if (!strncmp(szMsgBegin, "VMSG", strlen("VMSG"))) {
 858                                                                 if ((pVMsg = (VTree*)calloc(1, sizeof(VTree))) == NULL) {
 859                                                                         start_status = 1;
 860                                                                         goto CATCH;
 861                                                                 }
 862                                                                 memset(pVMsg, 0x00, sizeof(VTree));
 863
 864                                                                 pVMsg->treeType = VMESSAGE;
 865                                                                 pVMsg->pTop = NULL;
 866                                                                 pVMsg->pCur = NULL;
 867                                                                 pVMsg->pNext = NULL;
 868                                                                 pCurrent = pVMsg;
 869                                                         } else if (!strncmp(szMsgBegin, "VBODY", strlen("VBODY"))) {
 870                                                                 if ((pVBody = (VTree*)calloc(1, sizeof(VTree))) == NULL) {
 871                                                                         start_status = 1;
 872                                                                         goto CATCH;
 873                                                                 }
 874
 875                                                                 memset(pVBody, 0x00, sizeof(VTree));
 876                                                                 pVBody->treeType = VBODY;
 877                                                                 pVBody->pTop = NULL;
 878                                                                 pVBody->pCur = NULL;
 879                                                                 pVBody->pNext = NULL;
 880                                                                 pCurrent->pNext = pVBody;
 881                                                                 pCurrent = pVBody;
 882                                                         }
 883                                                 }
 884
 885                                                 VFREE(szMsgBegin);
 886                                                 break;
 887
 888                                         case VMSG_TYPE_END:
 889                                                 dLen = 0;
 890                                                 enc = 0;
 891                                                 //szMsgBegin = __VMsgGetTypeVal(pMsgRaw, &status, &dLen, enc, NULL);
 892
 893                                                 if (!strncmp(pMsgRaw, "VMSG", strlen("VMSG"))) {
 894                                                         done = true;
 895                                                         vmsg_ended = true;
 896                                                 } else {
 897                                                         status = VMSG_TYPE_NAME_STATUS;
 898                                                         //pMsgRaw += dLen;
 899                                                 }
 900                                                 VDATA_TRACE("pMsgRaw:%s", pMsgRaw);
 901                                                 pMsgRaw += dLen;
 902                                                 break;
 903
 904                                         case UNKNOWN_NAME:
 905                                                 break;
 906
 907                                         default:
 908                                                 if (UNKNOWN_NAME == type || type < 0) {
 909                                                         status = VMSG_TYPE_NAME_STATUS;
 910                                                         break;
 911                                                 }
 912
 913                                                 if ((pTemp = (VObject*)calloc(1, sizeof(VObject))) == NULL) {
 914                                                         goto CATCH;
 915                                                 }
 916
 917                                                 memset(pTemp, 0, sizeof(VObject));
 918                                                 pTemp->property = type;
 919
 920                                                 if (pCurrent->pTop == NULL) {
 921                                                         pCurrent->pTop = pTemp;
 922                                                         pCurrent->pCur = pTemp;
 923                                                 } else {
 924                                                         pCurrent->pCur->pSibling = pTemp;
 925                                                         pCurrent->pCur = pTemp;
 926                                                 }
 927
 928                                                 break;
 929                                 }
 930
 931                                 numberedParam = 0;
 932                                 param_status = false;
 933                                 valueCount = 0;
 934                                 break;
 935
 936                         case VMSG_PARAM_NAME_STATUS:
 937                         {
 938                                 dLen = 0;
 939                                 param = __VMsgGetParamName(pMsgRaw, &status, &dLen);
 940                                 pMsgRaw += dLen;
 941
 942                                 if (param_status != true) {
 943
 944                                         if ((pTmpParam = (VParam*)calloc(1, sizeof(VParam))) == NULL)
 945                                                         goto CATCH;
 946
 947                                         param_status = true;
 948                                         pCurrent->pCur->pParam = pTmpParam;
 949                                         memset(pTmpParam, 0x00, sizeof(VParam));
 950                                         VDATA_TRACE("pTmpParam : %p", pTmpParam);
 951                                 } else {
 952                                         if ((pTmpParam->pNext = (VParam*)calloc(1, sizeof(VParam))) == NULL)
 953                                                         goto CATCH;
 954
 955                                         pTmpParam = pTmpParam->pNext;
 956                                         memset(pTmpParam, 0x00, sizeof(VParam));
 957                                         VDATA_TRACE("pTmpParam : %p", pTmpParam);
 958                                 }
 959
 960                                 pTmpParam->parameter = param;
 961                                 break;
 962                         }
 963                         case VMSG_PARAM_VALUE_STATUS:
 964                                 dLen = 0;
 965                                 numberedParam = 0;
 966                                 switch (pTmpParam->parameter) {
 967                                         case VMSG_PARAM_TYPE:
 968                                                 szValue = __VMsgGetParamVal(pMsgRaw, &status, &dLen);
 969                                                 numberedParam |= __VMsgGetValue(szValue, pMsgTypeList, VMSG_TYPE_PARAM_NUM);
 970                                                 break;
 971                                         case VMSG_PARAM_VALUE:
 972                                                 szValue = __VMsgGetParamVal(pMsgRaw, &status, &dLen);
 973                                                 numberedParam |= __VMsgGetValue(szValue, pMsgValueList, VMSG_VALUE_PARAM_NUM);
 974                                                 break;
 975                                         case VMSG_PARAM_ENCODING:
 976                                                 szValue = __VMsgGetParamVal(pMsgRaw, &status, &dLen);
 977                                                 numberedParam |= __VMsgGetValue(szValue, pMsgEncList, VMSG_ENCODE_PARAM_NUM);
 978                                                 enc = numberedParam;
 979                                                 break;
 980                                         case VMSG_PARAM_CHARSET:
 981                                                 szValue = __VMsgGetParamVal(pMsgRaw, &status, &dLen);
 982                                                 numberedParam |= __VMsgGetValue(szValue, pMsgCharsetList, VMSG_CHARSET_PARAM_NUM);
 983                                                 break;
 984                                         case VMSG_PARAM_CONTEXT:
 985                                         case VMSG_PARAM_LANGUAGE:
 986                                                 // prevent 7605 08.03.13
 987                                                 szValue = __VMsgGetParamVal(pMsgRaw, &status, &dLen);
 988                                                 numberedParam = 0;
 989                                                 break;
 990                                         default:
 991                                                 szValue = __VMsgGetParamVal(pMsgRaw, &status, &dLen);
 992
 993                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgTypeList, VMSG_TYPE_PARAM_NUM, pTmpParam, VMSG_PARAM_TYPE, enc);
 994                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgValueList, VMSG_VALUE_PARAM_NUM, pTmpParam, VMSG_PARAM_VALUE, enc);
 995                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgEncList, VMSG_ENCODE_PARAM_NUM, pTmpParam, VMSG_PARAM_ENCODING, enc);
 996                                                 SET_PARAM_VALUE(numberedParam, szValue, pMsgCharsetList, VMSG_CHARSET_PARAM_NUM, pTmpParam, VMSG_PARAM_CHARSET, enc);
 997
 998                                                 numberedParam = 0;
 999                                                 pMsgRaw += dLen;
1000                                                 dLen = 0;
1001
1002                                                 break;
1003                                 }
1004
1005                                 VDATA_TRACE("%d, %s, %p", numberedParam, szValue, pTmpParam);
1006                                 pTmpParam->paramValue = numberedParam;
1007                                 pTmpParam->pNext = NULL;
1008                                 VFREE(szValue);
1009                                 pMsgRaw += dLen;
1010                                 break;
1011                         case VMSG_TYPE_VALUE_STATUS:
1012                                 dLen = 0;
1013                                 temp = __VMsgGetTypeVal(pMsgRaw, &status, &dLen, enc, pCurrent->pCur);
1014
1015                                 if (valueCount < VDATA_VALUE_COUNT_MAX) {
1016                                         pCurrent->pCur->pszValue[valueCount] = temp;
1017                                         valueCount++;
1018                                         pCurrent->pCur->valueCount = valueCount;
1019                                         VDATA_TRACE("object property: %d, value: %s", pCurrent->pCur->property, pCurrent->pCur->pszValue[valueCount - 1]);
1020                                 } else
1021                                         VFREE(temp);
1022
1023                                 pMsgRaw += dLen;
1024                                 break;
1025                 }
1026         }
1027         VDATA_TRACE("pMsgRawTmp: %s", pMsgRawTmp);
1028         //VFREE(pMsgRawTmp);
1029
1030         if (pVMsg->pTop == NULL) {
1031                 VDATA_TRACE("pVMsg->Top: NULL");
1032                 goto CATCH;
1033         }
1034
1035         if (!vmsg_ended) {
1036                 VDATA_TRACE("vmsg_ended: false");
1037                 goto CATCH1;
1038         }
1039         VDATA_TRACE_END
1040         return pVMsg;
1041
1042 CATCH:
1043         VFREE(pTemp);
1044 CATCH1:
1045         VFREE(szMsgBegin);
1046         VFREE(pMsgRawTmp);
1047         vmsg_free_vtree_memory(pVMsg);
1048         VDATA_TRACE_END
1049         return NULL;
1050 }
1051
1052 /*
1053  * vmsg_encode() compares the string and vMsg type, parameter value.
1054  *
1055  * @param       pVMsgRaw            Data which will be encoded
1056  * @return      char *              Encoded result
1057  */
1058 char* vmsg_encode(VTree *pVMsgRaw)
1059 {
1060         VDATA_TRACE_BEGINE
1061         char*           pVMsgRes = NULL;
1062         char*           pTmpVMsgRes = NULL;
1063         VTree*          pTmpTree = NULL;
1064         VObject *       pTmpObj =  NULL;
1065         char*           pTemp = NULL;
1066         int                     len;
1067         int                     total = 0;
1068         int             cnt = 0;
1069
1070         for (; cnt < pVMsgRaw->pTop->valueCount; cnt++) {
1071
1072                 if (pVMsgRaw->pTop->pszValue[cnt] == NULL)  {
1073                         VDATA_TRACE("pVMsgRaw->pTop->valueCount : %d", pVMsgRaw->pTop->valueCount);
1074                         VDATA_TRACE("pVMsgRaw->pTop->pszValue[%d] : %s", cnt, pVMsgRaw->pTop->pszValue[cnt]);
1075                         VDATA_TRACE_END
1076                         return NULL;
1077                 }
1078         }
1079
1080         pTmpTree = pVMsgRaw;
1081         pTmpObj = pVMsgRaw->pTop;
1082
1083         while (true) {
1084                 switch (pTmpTree->treeType) {
1085                         case VMESSAGE:
1086                                 if (pVMsgRes) {
1087                                         free(pVMsgRes);
1088                                         pVMsgRes = NULL;
1089                                 }
1090
1091                                 if ((pVMsgRes = (char *)calloc(1, sizeof(char) * (total += 13))) == NULL) {
1092                                         VDATA_TRACE("vmsg_encode:calloc failed\n");
1093                                         VDATA_TRACE_END
1094                                         return NULL;
1095                                 }
1096                                 memcpy(pVMsgRes, "BEGIN:VMSG\r\n", 13);
1097                                 break;
1098
1099                         case VBODY:
1100                                 if ((pTmpVMsgRes = (char *)realloc(pVMsgRes,  sizeof(char) * (total += 14))) == NULL) {
1101                                         VDATA_TRACE("vmsg_encode:realloc failed\n");
1102                                         VFREE(pVMsgRes);
1103                                         VDATA_TRACE_END
1104                                         return NULL;
1105                                 }
1106
1107                                 pVMsgRes = pTmpVMsgRes;
1108                                 g_strlcat(pVMsgRes, "BEGIN:VBODY\r\n", 13);
1109                                 break;
1110
1111                         case VCARD:
1112                                 break;
1113                 }
1114
1115                 while (true) {
1116                         if (pTmpObj == NULL)
1117                                 break;
1118
1119                         if ((pTemp = __VMsgTypeEncode(pTmpObj, pTmpObj->property == VCARD_TYPE_TEL ? "TEL" : pszMsgTypeList[pTmpObj->property])) != NULL) {
1120                                 if (pTmpTree->treeType == VCARD) {
1121                                         char* encoded  = NULL;
1122
1123                                         encoded = vcard_encode(pTmpTree);
1124                                         if (encoded == NULL) {
1125                                                 VDATA_TRACE("vcard_encode() failed\n");
1126                                                 VFREE(pTemp);
1127                                                 VFREE(pVMsgRes);
1128                                                 VDATA_TRACE_END
1129                                                 return NULL;
1130                                         }
1131
1132                                         len = strlen(encoded);
1133
1134                                         if ((pTmpVMsgRes = (char*)realloc(pVMsgRes, (total += len+10))) == NULL)        {
1135                                                 VDATA_TRACE("vmsg_encode():realloc failed\n");
1136                                                 VFREE(pTemp);
1137                                                 VFREE(encoded);
1138                                                 VFREE(pVMsgRes);
1139                                                 VDATA_TRACE_END
1140                                                 return NULL;
1141                                         }
1142
1143                                         pVMsgRes = pTmpVMsgRes;
1144                                         g_strlcat(pVMsgRes, encoded, len+10);
1145                                         VDATA_TRACE("pTemp : %s", encoded);
1146                                         VFREE(pTemp);
1147                                         VFREE(encoded);
1148                                         break;
1149                                 }  else {
1150                                         len = strlen(pTemp);
1151
1152                                         if ((pTmpVMsgRes = (char*)realloc(pVMsgRes, (total += len+10))) == NULL) {
1153                                                 VDATA_TRACE("vmsg_encode():realloc failed\n");
1154                                                 VFREE(pTemp);
1155                                                 VFREE(pVMsgRes);
1156                                                 VDATA_TRACE_END
1157                                                 return NULL;
1158                                         }
1159                                         pVMsgRes = pTmpVMsgRes;
1160                                         g_strlcat(pVMsgRes, pTemp, len+10);
1161                                         VDATA_TRACE("pTemp : %s", pTemp);
1162                                         VFREE(pTemp);
1163
1164                                         if (pTmpObj->pSibling != NULL)
1165                                                 pTmpObj = pTmpObj->pSibling;
1166                                         else
1167                                                 break;
1168                                 }
1169                         }
1170
1171
1172                 }
1173
1174                 switch (pTmpTree->treeType) {
1175                         case VBODY:
1176                                 if ((pTmpVMsgRes = (char *)realloc(pVMsgRes, (total += 12))) == NULL) {
1177                                         VFREE(pVMsgRes);
1178                                         VDATA_TRACE("vcal_encode():realloc failed\n");
1179                                         return NULL;
1180                                 }
1181
1182                                 pVMsgRes = pTmpVMsgRes;
1183                                 g_strlcat(pVMsgRes, "END:VBODY\r\n", 12);
1184                                 break;
1185
1186                         case VCARD:
1187                                 break;
1188
1189                         case VMESSAGE:
1190                                 break;
1191
1192                 }
1193
1194                 if (pTmpTree->pNext != NULL)
1195                         pTmpTree = pTmpTree->pNext;
1196                 else
1197                         break;
1198                 pTmpObj = pTmpTree->pTop;
1199         }
1200
1201         if ((pTmpVMsgRes = (char *)realloc(pVMsgRes, (total += 11))) == NULL) {
1202                 VDATA_TRACE("vmsg_encode:realloc failed\n");
1203                 VFREE(pVMsgRes);
1204                 VDATA_TRACE_END
1205                 return NULL;
1206         }
1207
1208         pVMsgRes = pTmpVMsgRes;
1209         g_strlcat(pVMsgRes, "END:VMSG\r\n", 11);
1210         VDATA_TRACE_END
1211         return pVMsgRes;
1212 }
1213
1214
1215 /*
1216  * VIsVmsgFile() verify VMsg file.
1217  *
1218  * @param       pVMsgRaw           Data which will be encoded
1219  * @return      int                 result (true or false)
1220  */
1221 int
1222 __VIsVmsgFile(char *pMsgRaw, int mode)
1223 {
1224         int i = 0;
1225         bool rtnValue = true;
1226         char *pszVmsgBegin = "BEGIN:VMSG";
1227
1228         switch (mode) {
1229                 case CHECK_START:
1230                         for (i = 0; i < 10; i++)
1231                                 if (*pszVmsgBegin++ != *pMsgRaw++)
1232                                         rtnValue = false;
1233                         break;
1234
1235                 default:
1236                         rtnValue = false;
1237         }
1238         VDATA_TRACE_END
1239         return rtnValue;
1240 }
1241
1242
1243 /*
1244  * vMsgTypeEncoder() compares the string and vMsg type, parameter value.
1245  *
1246  * @param               typeObj                         Data which will be encoded
1247  * @param               type                            Name of the type
1248  * @return      char *              Encoded result
1249  */
1250 char*
1251 __VMsgTypeEncode(VObject *pTypeObj, char *pType)
1252 {
1253         VDATA_TRACE_BEGINE
1254         int                     len;
1255         char*           pTemp = NULL;
1256         char*           szTypeValue = NULL;
1257         int                     i;
1258         int                     enc = 0;
1259         char*           pEncode = NULL;
1260         char*           pRes = NULL;
1261         int                     total = 0;
1262         int                     biLen = 0;
1263
1264         len = strlen(pType);
1265         biLen = pTypeObj->numOfBiData;
1266
1267         if ((szTypeValue = (char *)calloc(1, total += (len+1))) == NULL) {
1268                 VDATA_TRACE("__VMsgTypeEncode():calloc failed\n");
1269                 VDATA_TRACE_END
1270                 return NULL;
1271         }
1272         memset(szTypeValue, '\0', (len+1));
1273         g_strlcat(szTypeValue, pType, len+1);
1274
1275         pTemp = __VMsgParamEncode(pTypeObj, &enc);
1276         if (pTemp != NULL) {
1277                 len = strlen(pTemp);
1278                 if ((szTypeValue = (char *)realloc(szTypeValue, (total += len))) == NULL) {
1279                         VDATA_TRACE("__VMsgTypeEncode():realloc failed\n");
1280                         VFREE(pTemp);
1281                         pTemp = NULL
1282                         VDATA_TRACE_END;
1283                         return NULL;
1284                 }
1285                 g_strlcat(szTypeValue, pTemp, len);
1286                 VFREE(pTemp);
1287                 pTemp = NULL;
1288         }
1289
1290         if ((szTypeValue = (char *)realloc(szTypeValue, (total += 2))) == NULL) {
1291                 VDATA_TRACE_END
1292                 return NULL;
1293         }
1294
1295         g_strlcat(szTypeValue, ":", 2);
1296
1297         len = 0;
1298
1299         if (strcmp(pType, pszMsgTypeList[6]) != 0) {
1300                 for (i = 0; i < pTypeObj->valueCount; i++) {
1301
1302                         if (pTypeObj->pszValue[i] != NULL)
1303                                 len += strlen(pTypeObj->pszValue[i]);
1304          }
1305         } else
1306                 len += biLen;
1307
1308
1309         for (i = 0; i < pTypeObj->valueCount; i++) {
1310
1311                 if (i == 0) {
1312                         if ((pEncode = (char *)calloc(1, len+20)) == NULL) {
1313                                 VFREE(szTypeValue);
1314                                 VDATA_TRACE_END
1315                                 return NULL;
1316                         }
1317
1318                         memset(pEncode, '\0', len+20);
1319
1320                         if (strcmp(pType, pszMsgTypeList[6]) != 0) {
1321                                 g_strlcat(pEncode, pTypeObj->pszValue[i], 20);
1322                                 _VEscape(pEncode);
1323                         } else
1324                                 memcpy(pEncode, pTypeObj->pszValue[i], biLen);
1325                 } else {
1326                         char    buf[1000];
1327                         strncpy(buf, pTypeObj->pszValue[i], 999);
1328                         _VEscape(buf);
1329                         g_strlcat(pEncode, ";" , len+20);
1330                         g_strlcat(pEncode, buf , len+20);
1331                 }
1332         }
1333
1334         if (strcmp(pType, pszMsgTypeList[6]) != 0)      {
1335                 if (pEncode) {
1336                         g_strlcat(pEncode, "\0\0", 2);
1337                         len = strlen(pEncode);
1338                 }
1339         } else {
1340                 len = biLen;
1341         }
1342
1343         if (enc & pMsgEncList[2].flag) {
1344                 if ((pRes = (char *)calloc(1, len * 6 + 10)) == NULL) {
1345                         VFREE(pEncode);
1346                         VFREE(szTypeValue);
1347                         VDATA_TRACE_END
1348                         return NULL;
1349                 }
1350                 if (pEncode)
1351                         _VQPEncode(pRes, pEncode);
1352                 VFREE(pEncode);
1353         } else if (enc & pMsgEncList[1].flag) {
1354                 if ((pRes = (char *)calloc(1, (len * 8 / 6) + 48)) == NULL) {
1355                         VFREE(pEncode);
1356                         VFREE(szTypeValue);
1357                         VDATA_TRACE_END
1358                         return NULL;
1359                 }
1360
1361                 memset(pRes, '\0', ((len * 8 / 6) + 48));
1362                 _VB64Encode(pRes, pEncode, biLen);
1363                 VDATA_TRACE("Origin Size: %d, Allocated Size %d, Coverted Size: %d\n", biLen, (len * 8 / 6) + 48, strlen(pRes));
1364                 VFREE(pEncode);
1365         } else {
1366                 if ((pRes = (char *)calloc(1, len+30)) == NULL) {
1367                         VFREE(pEncode);
1368                         VFREE(szTypeValue);
1369                         VDATA_TRACE_END
1370                         return NULL;
1371                 }
1372                 memset(pRes, '\0', (len + 30));
1373                 if (pEncode) {
1374                         memcpy(pRes, pEncode, len);
1375                         VFREE(pEncode);
1376                 }
1377         }
1378
1379         if ((pRes = (char *)realloc(pRes, strlen(pRes) + 3)) == NULL) {
1380                 VFREE(pEncode);
1381                 VFREE(szTypeValue);
1382                 VDATA_TRACE_END
1383                 return NULL;
1384         }
1385         g_strlcat(pRes, "\r\n", strlen(pRes) + 2);
1386
1387         len = strlen(pRes);
1388
1389         if ((szTypeValue = (char *)realloc(szTypeValue, (total += (len+3)))) == NULL) {
1390                 VFREE(pEncode);
1391                 VFREE(pRes);
1392                 VDATA_TRACE_END
1393                 return NULL;
1394         }
1395
1396         g_strlcat(szTypeValue, pRes, total - 1);
1397
1398         if (strcmp(pType, pszMsgTypeList[6]) != 0) {
1399                 _VRLSpace(szTypeValue);
1400                 _VRTSpace(szTypeValue);
1401         }
1402
1403         VFREE(pRes);
1404
1405         VDATA_TRACE_END
1406         return szTypeValue;
1407 }
1408
1409 /**
1410  * __VMsgParamEncode() Parameter Encoding.
1411  *
1412  * @param               pTypeObj                Data which will be encoded
1413  * @param               pEnc                            Name of the type
1414  */
1415 char *
1416 __VMsgParamEncode(VObject* pTypeObj, int* pEnc)
1417 {
1418         VDATA_TRACE_BEGINE
1419         int i = 0;
1420         int len = 0;
1421         int sNum = 0;
1422         int shift = 0;
1423         bool bSupported;
1424         char* szParam = NULL;
1425         VParam* pTemp = NULL;
1426         ValueObj*       pList = NULL;
1427
1428         /** Paramter initialize. */
1429         pTemp = pTypeObj->pParam;
1430
1431         /** Momory Allocation for parameter string. */
1432         if (pTemp != NULL) {
1433                 if ((szParam = (char*)calloc(1, len += 2)) == NULL) {
1434                         VDATA_TRACE_END
1435                         return NULL;
1436                 }
1437                 memset(szParam, 0x00, 2);
1438         }
1439
1440         /** appending pamaters. */
1441         while (true) {
1442
1443                 if (pTemp == NULL) break;
1444
1445                 bSupported = false;
1446
1447                 /** Expand szParam string. For appending.*/
1448                 if ((szParam = (char *)realloc(szParam, len += 15)) == NULL) {
1449                         VDATA_TRACE_END
1450                         return NULL;
1451                 }
1452
1453                 /** appending paramter name. */
1454                 g_strlcat(szParam, ";" , len);
1455                 if (pTemp->parameter != VMSG_PARAM_TYPE) {
1456                         g_strlcat(szParam, pszMsgParamList[pTemp->parameter], len);
1457                         g_strlcat(szParam, "=", len);
1458                 }
1459
1460                 /** Set Parameter Value name. */
1461                 switch (pTemp->parameter) {
1462                         case VMSG_PARAM_ENCODING:
1463                                 *pEnc = pMsgEncList[pTemp->paramValue].flag;
1464                                 shift = VMSG_ENCODE_PARAM_NUM;
1465                                 pList = pMsgEncList; bSupported = true;
1466                                 break;
1467                         case VMSG_PARAM_TYPE:
1468                                 shift = VMSG_TYPE_PARAM_NUM;
1469                                 pList = pMsgTypeList; bSupported = true;
1470                                 break;
1471                         case VMSG_PARAM_VALUE:
1472                                 shift = VMSG_VALUE_PARAM_NUM;
1473                                 pList = pMsgValueList; bSupported = true;
1474                                 break;
1475                         case VMSG_PARAM_CHARSET:
1476                                 shift = VMSG_CHARSET_PARAM_NUM;
1477                                 pList = pMsgCharsetList; bSupported = true;
1478                                 break;
1479                         default:
1480                                 if ((szParam = (char*)realloc(szParam, 5)) == NULL) {
1481                                         VDATA_TRACE_END
1482                                         return NULL;
1483                                 }
1484                                 g_strlcat(szParam, "NONE", strlen("NONE"));
1485                 }
1486
1487                 /** exchage parameter value's to string.*/
1488                 if (bSupported == true) {
1489
1490                         for (i = 0, sNum = 0x00000001; i < shift; i++) {
1491
1492                                 if (pList[pTemp->paramValue].flag & sNum) {
1493                                         if ((szParam = (char *)realloc(szParam, (len += (strlen(pList[i].szName) + 2)))) == NULL) {
1494                                                 VDATA_TRACE_END
1495                                                 return NULL;
1496                                         }
1497
1498                                         g_strlcat(szParam, pList[i].szName, len);
1499                                         g_strlcat(szParam, "; ", len);
1500                                 }
1501
1502                                 sNum <<= 1;
1503                         }
1504                 }
1505
1506                 /** remove semicolon from tail. */
1507                 for (i = strlen(szParam); i > 0 ; i--) {
1508
1509                         if (szParam[i] == ' ' && szParam[i-1] == ';') {
1510                                 szParam[i-1] = '\0';
1511                                 break;
1512                         }
1513                 }
1514
1515                 if (pTemp->pNext != NULL)
1516                         pTemp = pTemp->pNext;
1517                 else
1518                         break;
1519         }
1520         VDATA_TRACE_END
1521         return szParam;
1522 }
1523
1524 bool
1525 vmsg_free_vtree_memory(VTree * pTree)
1526 {
1527         VDATA_TRACE_BEGINE
1528         if (pTree == NULL) {
1529                 VDATA_TRACE_END
1530                 return false;
1531         }
1532         VDATA_TRACE_END
1533         return __VMsgFreeVTreeMemory(pTree);
1534 }